def generate(**kwargs): for k_, v_ in kwargs.items(): setattr(opt, k_, v_) netg, netd = NetG(opt).eval(), NetD(opt).eval() noises = t.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std) noises = Variable(noises, volatile=True) map_location = lambda storage, loc: storage netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) if opt.gpu: netd.cuda() netg.cuda() noises = noises.cuda() fake_img = netg(noises) scores = netd(fake_img).data ipdb.set_trace() indexs = scores.topk(opt.gen_num)[1] result = [] for ii in indexs: result.append(fake_img.data[ii]) tv.utils.save_image(t.stack(result), opt.gen_img, normalize=True, range=(-1, 1))
def generate(**kwargs): """ 随机生成动漫头像,并根据netd的分数选择较好的 """ for k_, v_ in kwargs.items(): setattr(opt, k_, v_) device = t.device('cuda') if opt.gpu else t.device('cpu') netg, netd = NetG(opt).eval(), NetD(opt).eval() noises = t.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std) noises = noises.to(device) map_location = lambda storage, loc: storage netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) netd.to(device) netg.to(device) # 生成图片,并计算图片在判别器的分数 fake_img = netg(noises) scores = netd(fake_img).detach() # 挑选最好的某几张 indexs = scores.topk(opt.gen_num)[1] result = [] for ii in indexs: result.append(fake_img.data[ii]) # 保存图片 tv.utils.save_image(t.stack(result), opt.gen_img, normalize=True, range=(-1, 1))
def generate(**kwargs): """ 随机生成动漫头像,并根据netd的分数选择较好的 """ for k_, v_ in kwargs.items(): setattr(opt, k_, v_) device=t.device('cuda') if opt.gpu else t.device('cpu') netg, netd = NetG(opt).eval(), NetD(opt).eval() noises = t.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std) noises = noises.to(device) map_location = lambda storage, loc: storage netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) netd.to(device) netg.to(device) # 生成图片,并计算图片在判别器的分数 fake_img = netg(noises) scores = netd(fake_img).detach() # 挑选最好的某几张 indexs = scores.topk(opt.gen_num)[1] result = [] for ii in indexs: result.append(fake_img.data[ii]) # 保存图片 tv.utils.save_image(t.stack(result), opt.gen_img, normalize=True, range=(-1, 1))
def generate(**kwargs): ''' 随机生成动漫头像,并根据netd的分数选择较好的结果 :param kwargs: :return: ''' for k_, v_ in kwargs.items(): setattr(opt, k_, v_) netg,netd = NetG(opt).eval(),NetD(opt).eval() noises = t.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std) map_location = lambda storage, loc: storage netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) if opt.gpu: device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") netd.to(device) netg.to(device) noises.to(device) #生成图片 fake_img = netg(noises) scores = netd(fake_img).data #挑选最好的某几张 indexs = scores.topk(opt.gen_num)[1] result = [] for i in indexs: result.append(fake_img.data[ii]) #保存图片 tv.utils.save_image(t.stack(result),opt.gen_img,normalize=True,range=(-1,1))
def test(): #netG = torch.load('checkpoints/netG_013.pth') netG = NetG(conf.batch_size, conf.nz) netG.load_state_dict(torch.load('checkpoints/netG_013.pth')) #netG.eval() for i in range(1): noise = torch.randn(conf.batch_size, conf.nz, 1, 1) #3import pdb; pdb.set_trace() fake_img = netG(noise) #生成假图 #utils.img_show(fake_img) save_image(fake_img.data, './checkpoints/hehe.png')
def generate(**kwargs): """ 随机生成动漫头像,并根据netd的分数选择较好的 """ for k_, v_ in kwargs.items(): setattr(opt, k_, v_) device=t.device('cuda') if opt.gpu else t.device('cpu') netg, netd = NetG(opt).eval(), NetD(opt).eval() noises = t.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std) noises = noises.to(device) map_location = lambda storage, loc: storage netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) netd.to(device) netg.to(device) # 生成图片,并计算图片在判别器的分数 fake_img = netg(noises) scores = netd(fake_img).detach() # 挑选最好的某几张 indexs = scores.topk(opt.gen_num)[1] result = [] for ii in indexs: result.append(fake_img.data[ii]) # 保存图片 epoch_num = opt.netd_path[opt.netd_path.find("_") + 1:opt.netd_path.rfind(".")] randid = random.randint(0, 1000) pic_stack_name = "".join(["result_", str(epoch_num), "_", str(randid), ".png"]) tv.utils.save_image(t.stack(result), pic_stack_name, normalize=True, range=(-1, 1)) base_dir = "./imgs/tiny_epoch_{0}_{1}".format(epoch_num, randid) if not os.path.exists(base_dir): os.mkdir(base_dir) for picx in range(len(result)): picx_name = "".join([base_dir, "/picid_", str(picx), ".png"]) tv.utils.save_image(result[picx], picx_name, normalize=True, range=(-1, 1))
def generate(**kwargs): """ 随机生成动漫头像,并根据netd的分数选择较好的 """ for k_, v_ in kwargs.items(): setattr(opt, k_, v_) # 将网络模型置为预测模式 不保存中间结果,加速 netg, netd = NetG(opt).eval(), NetD(opt).eval() # 初始化gen_search_num张噪声,期望生成gen_search_num张预测图像 noises = t.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std) noises = Variable(noises, volatile=True) # 将模型参数加载到cpu中 map_location = lambda storage, loc: storage netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) # 模型和输入噪声转到GPU中 if opt.gpu: netd.cuda() netg.cuda() noises = noises.cuda() # 生成图片,并计算图片在判别器的分数 fake_img = netg(noises) scores = netd(fake_img).data # 挑选最好的某几张 从512章图片中按分数排序,取前64张 的下标 indexs = scores.topk(opt.gen_num)[1] result = [] for ii in indexs: result.append(fake_img.data[ii]) # 保存图片 tv.utils.save_image(t.stack(result), opt.gen_img, normalize=True, range=(-1, 1))
def generate(**kwargs): ''' 随机生成动漫头像,并根据netd的分数选择较好的 ''' for k_, v_ in kwargs.items(): setattr(opt, k_, v_) netg, netd = NetG(opt).eval(), NetD(opt).eval() # t.manual_seed(100) noises = t.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std) noises = Variable(noises, volatile=True) map_location = lambda storage, loc: storage netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) if opt.gpu: netd.cuda() netg.cuda() noises = noises.cuda() # 生成图片,并计算图片在判别器的分数 fake_img = netg(noises) scores = netd(fake_img).data # 挑选最好的某几张 indexs = scores.topk(opt.gen_num)[1] result = [] for ii in indexs: result.append(fake_img.data[ii]) # 保存图片 tv.utils.save_image(t.stack(result), opt.gen_img, normalize=True, range=(-1, 1))
def train(**kwargs): for k_, v_ in kwargs.items(): setattr(opt, k_, v_) device = t.device("cuda") if opt.gpu else t.device("cpu") # 数据处理,输出规范为-1~1 transforms = tv.transforms.Compose([ tv.transforms.Resize(opt.image_size), tv.transforms.CenterCrop(opt.image_size), tv.transforms.ToTensor(), tv.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) dataset = tv.datasets.ImageFolder(opt.data_path, transform=transforms) dataloader = t.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True) # 网络 netg, netd = NetG(opt), NetD(opt) map_location = lambda storage, loc: storage if opt.netd_path: netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) if opt.netg_path: netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) netd.to(device) netg.to(device) # 定义优化器和损失 optimizer_g = t.optim.Adam(netg.parameters(), opt.lr1, betas=(opt.beta1, 0.999)) optimizer_d = t.optim.Adam(netd.parameters(), opt.lr2, betas=(opt.beta1, 0.999)) criterion = t.nn.BCELoss() # 真图片label为1,假图片label为0, noise为生成网络的输入 true_labels = t.ones(opt.batch_size).to(device) fake_labels = t.zeros(opt.batch_size).to(device) fix_noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device) noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device) # 用来结果的均值和标准差 errord_meter = AverageValueMeter() errorg_meter = AverageValueMeter() epochs = range(opt.max_epoch) for epoch in iter(epochs): for ii, (img, _) in tqdm.tqdm(enumerate(dataloader)): real_img = img.to(device) if ii % opt.d_every == 0: # 训练判别器 optimizer_d.zero_grad() ## 尽可能把真图片判别为正 output = netd(real_img) error_d_real = criterion(output, true_labels) error_d_real.backward() ## 尽可能把假图片判断为错误 noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) # 使用detach来关闭G求梯度,加速训练 fake_img = netg(noises).detach() output = netd(fake_img) error_d_fake = criterion(output, fake_labels) error_d_fake.backward() optimizer_d.step() error_d = error_d_fake + error_d_real errord_meter.add(error_d.item()) if ii % opt.g_every == 0: # 训练生成器 optimizer_g.zero_grad() noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises) output = netd(fake_img) # 尽可能把假的图片也判别为1 error_g = criterion(output, true_labels) error_g.backward() optimizer_g.step() errorg_meter.add(error_g.item()) # 可视化 # 保存模型、图片 if (epoch + 1) % opt.save_every == 0: fix_fake_imgs = netg(fix_noises) tv.utils.save_image(fix_fake_imgs.data[:64], "%s%s.png" % (opt.save_path, epoch), normalize=True, range=(-1, 1)) t.save(netd.state_dict(), r"./checkpoints/netd_%s.pth" % epoch) t.save(netg.state_dict(), r"./checkpoints/netg_%s.pth" % epoch) errord_meter.reset() errorg_meter.reset()
def train(**kwargs): for k_, v_ in kwargs.items(): setattr(opt, k_, v_) device=t.device('cuda') if opt.gpu else t.device('cpu') if opt.vis: from visualize import Visualizer vis = Visualizer(opt.env) # 数据 transforms = tv.transforms.Compose([ tv.transforms.Resize(opt.image_size), tv.transforms.CenterCrop(opt.image_size), tv.transforms.ToTensor(), tv.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) dataset = tv.datasets.ImageFolder(opt.data_path, transform=transforms) dataloader = t.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True ) # 网络 netg, netd = NetG(opt), NetD(opt) map_location = lambda storage, loc: storage if opt.netd_path: netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) if opt.netg_path: netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) netd.to(device) netg.to(device) # 定义优化器和损失 optimizer_g = t.optim.Adam(netg.parameters(), opt.lr1, betas=(opt.beta1, 0.999)) optimizer_d = t.optim.Adam(netd.parameters(), opt.lr2, betas=(opt.beta1, 0.999)) criterion = t.nn.BCELoss().to(device) # 真图片label为1,假图片label为0 # noises为生成网络的输入 true_labels = t.ones(opt.batch_size).to(device) fake_labels = t.zeros(opt.batch_size).to(device) fix_noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device) noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device) errord_meter = AverageValueMeter() errorg_meter = AverageValueMeter() epochs = range(opt.max_epoch) for epoch in iter(epochs): for ii, (img, _) in tqdm.tqdm(enumerate(dataloader)): real_img = img.to(device) if ii % opt.d_every == 0: # 训练判别器 optimizer_d.zero_grad() ## 尽可能的把真图片判别为正确 output = netd(real_img) error_d_real = criterion(output, true_labels) error_d_real.backward() ## 尽可能把假图片判别为错误 noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises).detach() # 根据噪声生成假图 output = netd(fake_img) error_d_fake = criterion(output, fake_labels) error_d_fake.backward() optimizer_d.step() error_d = error_d_fake + error_d_real errord_meter.add(error_d.item()) if ii % opt.g_every == 0: # 训练生成器 optimizer_g.zero_grad() noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises) output = netd(fake_img) error_g = criterion(output, true_labels) error_g.backward() optimizer_g.step() errorg_meter.add(error_g.item()) if opt.vis and ii % opt.plot_every == opt.plot_every - 1: ## 可视化 if os.path.exists(opt.debug_file): ipdb.set_trace() fix_fake_imgs = netg(fix_noises) vis.images(fix_fake_imgs.detach().cpu().numpy()[:64] * 0.5 + 0.5, win='fixfake') vis.images(real_img.data.cpu().numpy()[:64] * 0.5 + 0.5, win='real') vis.plot('errord', errord_meter.value()[0]) vis.plot('errorg', errorg_meter.value()[0]) if (epoch+1) % opt.save_every == 0: # 保存模型、图片 tv.utils.save_image(fix_fake_imgs.data[:64], '%s/%s.png' % (opt.save_path, epoch), normalize=True, range=(-1, 1)) t.save(netd.state_dict(), 'checkpoints/netd_%s.pth' % epoch) t.save(netg.state_dict(), 'checkpoints/netg_%s.pth' % epoch) errord_meter.reset() errorg_meter.reset()
def test_network(): threshold = ct.THRESHOLD test_dir = ct.TEST_TXT path = os.path.join(ct.BEST_WEIGHT_SAVE_DIR, 'netG.pth') device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') pretrained_dict = torch.load( path, map_location=torch.device(device))['model_state_dict'] test_data = OSCD_TEST(test_dir) test_dataloader = DataLoader(test_data, batch_size=1, shuffle=False) net = NetG(ct.ISIZE, ct.NC * 2, ct.NZ, ct.NDF, ct.EXTRALAYERS).to(device) # net = nn.DataParallel(net) net.load_state_dict(pretrained_dict, False) torch.no_grad() net.eval() i = 0 TP = 0 FN = 0 FP = 0 TN = 0 for i, data in enumerate(test_dataloader): INPUT_SIZE = [ct.ISIZE, ct.ISIZE] x1, x2, gt = data x1 = x1.to(device, dtype=torch.float) x2 = x2.to(device, dtype=torch.float) gt = gt.to(device, dtype=torch.float) gt = gt[:, 0, :, :].unsqueeze(1) x = torch.cat((x1, x2), 1) fake = net(x) save_path = os.path.join(ct.IM_SAVE_DIR, 'test_output_images') if not os.path.isdir(save_path): os.makedirs(save_path) if ct.SAVE_TEST_IAMGES: vutils.save_image(x1.data, os.path.join(save_path, '%d_x1.png' % i), normalize=True) vutils.save_image(x2.data, os.path.join(save_path, '%d_x2.png' % i), normalize=True) vutils.save_image(fake.data, os.path.join(save_path, '%d_gt_fake.png' % i), normalize=True) vutils.save_image(gt, os.path.join(save_path, '%d_gt.png' % i), normalize=True) tp, fp, tn, fn = eva.f1(fake, gt) TP += tp FN += fn TN += tn FP += fp i += 1 print('testing {}th images'.format(i)) iou = TP / (FN + TP + FP + 1e-8) precision = TP / (TP + FP + 1e-8) oa = (TP + TN) / (TP + FN + TN + FP + 1e-8) recall = TP / (TP + FN + 1e-8) f1 = 2 * precision * recall / (precision + recall + 1e-8) P = ((TP + FP) * (TP + FN) + (FN + TN) * (FP + TN)) / ((TP + TN + FP + FN)**2 + 1e-8) Kappa = (oa - P) / (1 - P + 1e-8) results = { 'iou': iou, 'precision': precision, 'oa': oa, 'recall': recall, 'f1': f1, 'kappa': Kappa } with open(os.path.join(ct.OUTPUTS_DIR, 'test_score.txt'), 'a') as f: f.write('-----test results on the best model {}-----'.format( time.strftime('%Y-%m-%d %H:%M:%S'))) f.write('\n') for key, value in results.items(): print(key, value) f.write('{}: {}'.format(key, value)) f.write('\n')
def train(**kwargs): for k_, v_ in kwargs.items(): setattr(opt, k_, v_) device = t.device('cuda') if opt.gpu else t.device('cpu') # 可视化 if opt.vis: from visualize import Visualizer vis = Visualizer(opt.env) # 数据 transforms = tv.transforms.Compose([ tv.transforms.Resize(opt.image_size), tv.transforms.CenterCrop(opt.image_size), tv.transforms.ToTensor(), tv.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) dataset = tv.datasets.ImageFolder(opt.data_path, transforms) dataloader = t.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True) netg, netd = NetG(opt), NetD(opt) if opt.netd_path: netd.load_state_dict( t.load(opt.netd_path, map_location=t.device('cpu'))) if opt.netg_path: netg.load_state_dict( t.load(opt.netg_path, map_location=t.device('cpu'))) netd.to(device) netg.to(device) # 定义优化器和损失 optimizer_g = t.optim.Adam(netg.parameters(), opt.lr1, betas=(opt.beta1, 0.999)) optimizer_d = t.optim.Adam(netd.parameters(), opt.lr1, betas=(opt.beta1, 0.999)) criterion = t.nn.BCELoss().to(device) # 真图片label为1,假图片label为0 # noise为生成网络的输入 true_labels = t.ones(opt.batch_size).to(device) fake_labels = t.zeros(opt.batch_size).to(device) fix_noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device) noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device) errord = 0 errorg = 0 epochs = range(opt.max_epoch) for epoch in epochs: for ii, (img, _) in tqdm(enumerate(dataloader)): real_img = img.to(device) if (ii + 1) % opt.d_every == 0: # 训练判别器 optimizer_d.zero_grad() # 把真图片判断为正确 output = netd(real_img) error_d_real = criterion(output, true_labels) error_d_real.backward() # 把假图片(netg通过噪声生成的图片)判断为错误 noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises).detach() output = netd(fake_img) error_d_fake = criterion(output, fake_labels) error_d_fake.backward() optimizer_d.step() errord += (error_d_fake + error_d_real).item() if (ii + 1) % opt.g_every == 0: # 训练生成器 optimizer_g.zero_grad() noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises) output = netd(fake_img) error_g = criterion(output, true_labels) error_g.backward() optimizer_g.step() errorg += error_g.item() if opt.vis and (ii + 1) % opt.plot_every == 0: fix_fake_imgs = netg(fix_noises) vis.images(fix_fake_imgs.detach().cpu().numpy()[:64] * 0.5 + 0.5, win='fixfake') vis.images(real_img.data.cpu().numpy()[:64] * 0.5 + 0.5, win='real') vis.plot('errord', errord / (opt.plot_every)) vis.plot('errorg', errorg / (opt.plot_every)) errord = 0 errorg = 0 if (epoch + 1) % opt.save_every == 0: tv.utils.save_image(fix_fake_imgs.data[:64], '%s%s.png' % (opt.save_path, epoch), normalize=True, range=(-1, 1)) t.save(netd.state_dict(), 'checkpoints/netd_%s.pth' % (epoch + 1)) t.save(netg.state_dict(), 'checkpoints/netg_%s.pth' % (epoch + 1))
wandb.init( config=CONFIG, name=CONFIG.name, project="mnist", # have to change when you want to change project job_type="anomaly detection", ) state_dict_G = torch.load("weights/G.prm", map_location=lambda storage, loc: storage) state_dict_D = torch.load("weights/D.prm", map_location=lambda storage, loc: storage) G_update = NetG(CONFIG) D_update = NetD(CONFIG) G_update.load_state_dict(state_dict_G) D_update.load_state_dict(state_dict_D) G_update.to(device) D_update.to(device) mean = (0.5, ) std = (0.5, ) test_dataset = Dataset(csv_file=CONFIG.test_csv_file, transform=ImageTransform(mean, std)) test_dataloader = DataLoader(test_dataset, batch_size=CONFIG.test_batch_size, shuffle=True)
""""" In order to be able to verify the trained generator model, here I will verify the robustness of the model through an example-by generating an image data and saving it in a local folder """ "" import argparse from model import NetG import torch from torch.autograd import Variable import torchvision.utils as vutils parser = argparse.ArgumentParser() parser.add_argument('--batchSize', type=int, default=64) opt = parser.parse_args() if __name__ == '__main__': print(opt) net = NetG(64, 100) net.load_state_dict(torch.load("./model_save/xxxx.pth")) data = torch.randn(100, 1, 1) data = Variable(data.unsqueeze(0)) output = net(data) vutils.save_image(output.data, './test.png', normalize=True)
def generate(**kwargs): """ 随机生成动漫头像,并根据netd的分数选择较好的 """ for k_, v_ in kwargs.items(): setattr(opt, k_, v_) device = torch.device('cuda') if opt.gpu else torch.device('cpu') hash_id = hash(opt.gen_id) % 51603 torch.manual_seed(hash_id) netg, netd = NetG(opt).eval(), NetD(opt).eval() noises = torch.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std) noises = noises.to(device) map_location = lambda storage, loc: storage netd.load_state_dict(torch.load(opt.netd_path, map_location=map_location)) netg.load_state_dict(torch.load(opt.netg_path, map_location=map_location)) netd.to(device) netg.to(device) # 生成图片,并计算图片在判别器的分数 fake_img = netg(noises) scores = netd(fake_img).detach() # 挑选最好的某几张 indexs = scores.topk(opt.gen_num)[1] result = [] for ii in indexs: result.append(fake_img.data[ii]) # 保存图片 # epoch_num = opt.netd_path[opt.netd_path.find("_") + 1:opt.netd_path.rfind(".")] # pic_stack_name = "".join(["result_", str(epoch_num), "_", str(randid), ".png"]) print(result[0]) print(result[0].size()) # np_array = result[0].cpu().numpy() # # trans_array = np.zeros((96,96,3)) # # trans_array[:,:,0] = np_array[0,:,:] # trans_array[:,:,1] = np_array[1,:,:] # trans_array[:,:,2] = np_array[2,:,:] # # print(trans_array.shape) # # img_ = Image.fromarray(np.uint8(trans_array*255)) # img_ = img_.resize((224, 224), Image.BILINEAR) #resize to # t_img = torch.from_numpy(np.array(img_)) # tv.utils.save_image(t_img, "PIL_test_img.png", normalize=True, range=(-0.8, 0.8)) #tv.utils.save_image(torch.stack(result), "save_test.png", normalize=True, range=(-1, 1)) base_dir = opt.gen_dst base_name = opt.base_name if not os.path.exists(base_dir): os.mkdir(base_dir) for picx in range(len(result)): picx_name = "".join([base_dir, base_name, str(picx), ".png"]) tv.utils.save_image(result[picx], picx_name, normalize=True, range=(-0.8, 0.8)) img = Image.open(picx_name) img = img.resize((188, 188), Image.ANTIALIAS) img.save(base_dir + "/" + str(picx) + ".png", "png") os.remove(picx_name)
def train_network(): init_epoch = 0 best_f1 = 0 total_steps = 0 train_dir = ct.TRAIN_TXT val_dir = ct.VAL_TXT device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') torch.backends.cudnn.benchmark = True train_data = OSCD_TRAIN(train_dir) train_dataloader = DataLoader(train_data, batch_size=ct.BATCH_SIZE, shuffle=True) val_data = OSCD_TEST(val_dir) val_dataloader = DataLoader(val_data, batch_size=1, shuffle=False) netg = NetG(ct.ISIZE, ct.NC * 2, ct.NZ, ct.NDF, ct.EXTRALAYERS).to(device=device) netd = NetD(ct.ISIZE, ct.GT_C, 1, ct.NGF, ct.EXTRALAYERS).to(device=device) netg.apply(weights_init) netd.apply(weights_init) if ct.RESUME: assert os.path.exists(os.path.join(ct.WEIGHTS_SAVE_DIR, 'current_netG.pth')) \ and os.path.exists(os.path.join(ct.WEIGHTS_SAVE_DIR, 'current_netG.pth')), \ 'There is not found any saved weights' print("\nLoading pre-trained networks.") init_epoch = torch.load( os.path.join(ct.WEIGHTS_SAVE_DIR, 'current_netG.pth'))['epoch'] netg.load_state_dict( torch.load(os.path.join(ct.WEIGHTS_SAVE_DIR, 'current_netG.pth'))['model_state_dict']) netd.load_state_dict( torch.load(os.path.join(ct.WEIGHTS_SAVE_DIR, 'current_netD.pth'))['model_state_dict']) with open(os.path.join(ct.OUTPUTS_DIR, 'f1_score.txt')) as f: lines = f.readlines() best_f1 = float(lines[-2].strip().split(':')[-1]) print("\tDone.\n") l_adv = l2_loss l_con = nn.L1Loss() l_enc = l2_loss l_bce = nn.BCELoss() l_cos = cos_loss dice = DiceLoss() optimizer_d = optim.Adam(netd.parameters(), lr=ct.LR, betas=(0.5, 0.999)) optimizer_g = optim.Adam(netg.parameters(), lr=ct.LR, betas=(0.5, 0.999)) start_time = time.time() for epoch in range(init_epoch + 1, ct.EPOCH): loss_g = [] loss_d = [] netg.train() netd.train() epoch_iter = 0 for i, data in enumerate(train_dataloader): INPUT_SIZE = [ct.ISIZE, ct.ISIZE] x1, x2, gt = data x1 = x1.to(device, dtype=torch.float) x2 = x2.to(device, dtype=torch.float) gt = gt.to(device, dtype=torch.float) gt = gt[:, 0, :, :].unsqueeze(1) x = torch.cat((x1, x2), 1) epoch_iter += ct.BATCH_SIZE total_steps += ct.BATCH_SIZE real_label = torch.ones(size=(x1.shape[0], ), dtype=torch.float32, device=device) fake_label = torch.zeros(size=(x1.shape[0], ), dtype=torch.float32, device=device) #forward fake = netg(x) pred_real = netd(gt) pred_fake = netd(fake).detach() err_d_fake = l_bce(pred_fake, fake_label) err_g = l_con(fake, gt) err_g_total = ct.G_WEIGHT * err_g + ct.D_WEIGHT * err_d_fake pred_fake_ = netd(fake.detach()) err_d_real = l_bce(pred_real, real_label) err_d_fake_ = l_bce(pred_fake_, fake_label) err_d_total = (err_d_real + err_d_fake_) * 0.5 #backward optimizer_g.zero_grad() err_g_total.backward(retain_graph=True) optimizer_g.step() optimizer_d.zero_grad() err_d_total.backward() optimizer_d.step() errors = utils.get_errors(err_d_total, err_g_total) loss_g.append(err_g_total.item()) loss_d.append(err_d_total.item()) counter_ratio = float(epoch_iter) / len(train_dataloader.dataset) if (i % ct.DISPOLAY_STEP == 0 and i > 0): print( 'epoch:', epoch, 'iteration:', i, ' G|D loss is {}|{}'.format(np.mean(loss_g[-51:]), np.mean(loss_d[-51:]))) if ct.DISPLAY: utils.plot_current_errors(epoch, counter_ratio, errors, vis) utils.display_current_images(gt.data, fake.data, vis) utils.save_current_images(epoch, gt.data, fake.data, ct.IM_SAVE_DIR, 'training_output_images') with open(os.path.join(ct.OUTPUTS_DIR, 'train_loss.txt'), 'a') as f: f.write( 'after %s epoch, loss is %g,loss1 is %g,loss2 is %g,loss3 is %g' % (epoch, np.mean(loss_g), np.mean(loss_d), np.mean(loss_g), np.mean(loss_d))) f.write('\n') if not os.path.exists(ct.WEIGHTS_SAVE_DIR): os.makedirs(ct.WEIGHTS_SAVE_DIR) utils.save_weights(epoch, netg, optimizer_g, ct.WEIGHTS_SAVE_DIR, 'netG') utils.save_weights(epoch, netd, optimizer_d, ct.WEIGHTS_SAVE_DIR, 'netD') duration = time.time() - start_time print('training duration is %g' % duration) #val phase print('Validating.................') pretrained_dict = torch.load( os.path.join(ct.WEIGHTS_SAVE_DIR, 'current_netG.pth'))['model_state_dict'] device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') net = NetG(ct.ISIZE, ct.NC * 2, ct.NZ, ct.NDF, ct.EXTRALAYERS).to(device=device) net.load_state_dict(pretrained_dict, False) with net.eval() and torch.no_grad(): TP = 0 FN = 0 FP = 0 TN = 0 for k, data in enumerate(val_dataloader): x1, x2, label = data x1 = x1.to(device, dtype=torch.float) x2 = x2.to(device, dtype=torch.float) label = label.to(device, dtype=torch.float) label = label[:, 0, :, :].unsqueeze(1) x = torch.cat((x1, x2), 1) time_i = time.time() v_fake = net(x) tp, fp, tn, fn = eva.f1(v_fake, label) TP += tp FN += fn TN += tn FP += fp precision = TP / (TP + FP + 1e-8) oa = (TP + TN) / (TP + FN + TN + FP + 1e-8) recall = TP / (TP + FN + 1e-8) f1 = 2 * precision * recall / (precision + recall + 1e-8) if not os.path.exists(ct.BEST_WEIGHT_SAVE_DIR): os.makedirs(ct.BEST_WEIGHT_SAVE_DIR) if f1 > best_f1: best_f1 = f1 shutil.copy( os.path.join(ct.WEIGHTS_SAVE_DIR, 'current_netG.pth'), os.path.join(ct.BEST_WEIGHT_SAVE_DIR, 'netG.pth')) print('current F1: {}'.format(f1)) print('best f1: {}'.format(best_f1)) with open(os.path.join(ct.OUTPUTS_DIR, 'f1_score.txt'), 'a') as f: f.write('current epoch:{},current f1:{},best f1:{}'.format( epoch, f1, best_f1)) f.write('\n')
ndf = 64 nz = 100 opt = Config() for gen in range(gen_num): Result = random.randint(1000000, 100000000) device = t.device('cuda') if opt.gpu else t.device('cpu') netg, netd = NetG(opt).eval(), NetD(opt).eval() noises = t.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std) noises = noises.to(device) map_location = lambda storage, loc: storage netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) netd.to(device) netg.to(device) fake_img = netg(noises) scores = netd(fake_img).detach() indexs = scores.topk(opt.gen_num)[1] result = [] for ii in indexs: result.append(fake_img.data[ii]) tv.utils.save_image(t.stack(result), str(Result) + opt.gen_img, normalize=True, range=(-1, 1))
def train(**kwargs): for k_, v_ in kwargs.items(): setattr(opt, k_, v_) if opt.vis: from visualizer import Visualizer vis = Visualizer(opt.env) transforms = tv.transforms.Compose([ tv.transforms.Scale(opt.image_size), tv.transforms.CenterCrop(opt.image_size), tv.transforms.ToTensor(), tv.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) dataset = tv.datasets.ImageFolder(opt.data_path, transform=transforms) dataloader = t.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True) netg, netd = NetG(opt), NetD(opt) map_location = lambda storage, loc: storage if opt.netd_path: netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) if opt.netg_path: netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) optimizer_g = t.optim.Adam(netg.parameters(), opt.lr1, betas=(opt.beta1, 0.999)) optimizer_d = t.optim.Adam(netd.parameters(), opt.lr2, betas=(opt.beta1, 0.999)) criterion = t.nn.BCELoss() true_labels = Variable(t.ones(opt.batch_size)) fake_labels = Variable(t.zeros(opt.batch_size)) fix_noises = Variable(t.randn(opt.batch_size, opt.nz, 1, 1)) noises = Variable(t.randn(opt.batch_size, opt.nz, 1, 1)) errord_meter = AverageValueMeter() errorg_meter = AverageValueMeter() if opt.gpu: netd.cuda() netg.cuda() criterion.cuda() true_labels, fake_labels = true_labels.cuda(), fake_labels.cuda() fix_noises, noises = fix_noises.cuda(), noises.cuda() epochs = range(opt.max_epoch) for epoch in iter(epochs): for ii, (img, _) in tqdm.tqdm(enumerate(dataloader)): real_img = Variable(img) if opt.gpu: real_img = real_img.cuda() if ii % opt.d_every == 0: optimizer_d.zero_grad() output = netd(real_img) error_d_real = criterion(output, true_labels) error_d_real.backward() noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises).detach() output = netd(fake_img) error_d_fake = criterion(output, fake_labels) error_d_fake.backward() optimizer_d.step() error_d = error_d_fake + error_d_real error_meter.add(error_d.data[0]) if ii % opt.g_every == 0: optimizer_g.zero_grad() noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises) output = netd(fake_img).detach() error_g = criterion(output, true_labels) error_g.backward() optimizer_g.step() errorg_meter.add(error_g.data[0]) if opt.vis and ii % opt.plot_every == opt.plot_every - 1: if os.path.exists(opt.debug_file): ipdb.set_trace() fix_fake_imgs = netg(fix_noises) vis.images(fix_fake_imgs.data.cpu().numpy()[:64] * 0.5 + 0.5, win='fixfake') vis.images(real_img.data.cpu().numpy()[:64] * 0.5 + 0.5, win='real') vis.plot('errord', errord_meter.value()[0]) vis.plot('errorg', errorg_meter.value()[0]) if epoch % opt.decay_every == 0: tv.utils.save_image(fix_fake_imgs.data[:64], '%s/%s.png' % (opt.save_path, epoch), Normalize=True, range=(-1, 1)) t.save(netd.state_dict(), 'checkpoints/netd_%s.pth' % epoch) t.save(netg.state_dict(), 'checkpoints/netg_%s.pth' % epoch) errord_meter.reset() errorg_meter.reset()
class TACGAN(): def __init__(self, args): self.lr = args.lr self.cuda = args.use_cuda self.batch_size = args.batch_size self.image_size = args.image_size self.epochs = args.epochs self.data_root = args.data_root self.dataset = args.dataset self.save_dir = args.save_dir self.save_prefix = args.save_prefix self.continue_training = args.continue_training self.continue_epoch = args.continue_epoch self.netG_path = args.netg_path self.netD_path = args.netd_path self.save_after = args.save_after self.trainset_loader = None self.evalset_loader = None self.num_workers = args.num_workers self.docvec_size = args.docvec_size self.n_z = args.n_z # length of the noise vector self.nl_d = args.nl_d self.nl_g = args.nl_g self.nf_g = args.nf_g self.nf_d = args.nf_d self.bce_loss = nn.BCELoss() self.nll_loss = nn.NLLLoss() self.mse_loss = nn.MSELoss() self.class_filename = args.class_filename class_path = os.path.join(self.data_root, self.dataset, self.class_filename) with open(class_path) as f: self.num_classes = len([l for l in f]) print(self.num_classes) self.netD = NetD(n_cls=self.num_classes, n_t=self.nl_d, n_f=self.nf_d, docvec_size=self.docvec_size) self.netG = NetG(n_z=self.n_z, n_l=self.nl_g, n_c=self.nf_g, n_t=self.docvec_size) if self.continue_training: self.loadCheckpoints() # convert to cuda tensors if self.cuda and torch.cuda.is_available(): print('CUDA is enabled') self.netD = nn.DataParallel(self.netD).cuda() self.netG = nn.DataParallel(self.netG).cuda() self.bce_loss = self.bce_loss.cuda() self.nll_loss = self.nll_loss.cuda() self.mse_loss = self.mse_loss.cuda() # optimizers for netD and netG self.optimizerD = optim.Adam(params=self.netD.parameters(), lr=self.lr, betas=(0.5, 0.999)) self.optimizerG = optim.Adam(params=self.netG.parameters(), lr=self.lr, betas=(0.5, 0.999)) # create dir for saving checkpoints and other results if do not exist if not os.path.exists(self.save_dir): os.makedirs(self.save_dir) if not os.path.exists(os.path.join(self.save_dir,'netd_checkpoints')): os.makedirs(os.path.join(self.save_dir,'netd_checkpoints')) if not os.path.exists(os.path.join(self.save_dir,'netg_checkpoints')): os.makedirs(os.path.join(self.save_dir,'netg_checkpoints')) if not os.path.exists(os.path.join(self.save_dir,'generated_images')): os.makedirs(os.path.join(self.save_dir,'generated_images')) # start training process def train(self): # write to the log file and print it log_msg = '********************************************\n' log_msg += ' Training Parameters\n' log_msg += 'Dataset:%s\nImage size:%dx%d\n'%(self.dataset, self.image_size, self.image_size) log_msg += 'Batch size:%d\n'%(self.batch_size) log_msg += 'Number of epochs:%d\nlr:%f\n'%(self.epochs,self.lr) log_msg += 'nz:%d\nnl-d:%d\nnl-g:%d\n'%(self.n_z, self.nl_d, self.nl_g) log_msg += 'nf-g:%d\nnf-d:%d\n'%(self.nf_g, self.nf_d) log_msg += '********************************************\n\n' print(log_msg) with open(os.path.join(self.save_dir, 'training_log.txt'),'a') as log_file: log_file.write(log_msg) # load trainset and evalset imtext_ds = ImTextDataset(data_dir=self.data_root, dataset=self.dataset, train=True, image_size=self.image_size) self.trainset_loader = DataLoader(dataset=imtext_ds, batch_size=self.batch_size, shuffle=True, num_workers=self.num_workers) print("Dataset loaded successfuly") # load checkpoints for continuing training # repeat for the number of epochs netd_losses = [] netg_losses = [] for epoch in range(self.epochs): netd_loss, netg_loss = self.trainEpoch(epoch) netd_losses.append(netd_loss) netg_losses.append(netg_loss) self.saveGraph(netd_losses,netg_losses) #self.evalEpoch(epoch) self.saveCheckpoints(epoch) # train epoch def trainEpoch(self, epoch): self.netD.train() # set to train mode self.netG.train() #! set to train mode??? netd_loss_sum = 0 netg_loss_sum = 0 start_time = time() for i, (images, labels, captions) in enumerate(self.trainset_loader): batch_size = images.size(0) # !batch size my be different (from self.batch_size) for the last batch images, labels, captions = Variable(images), Variable(labels), Variable(captions) # !labels should be LongTensor labels = labels.type(torch.FloatTensor) # convert to FloatTensor (from DoubleTensor) lbl_real = Variable(torch.ones(batch_size, 1)) lbl_fake = Variable(torch.zeros(batch_size, 1)) noise = Variable(torch.randn(batch_size, self.n_z)) # create random noise noise.data.normal_(0,1) # normalize the noise rnd_perm1 = torch.randperm(batch_size) # random permutations for different sets of training tuples rnd_perm2 = torch.randperm(batch_size) rnd_perm3 = torch.randperm(batch_size) rnd_perm4 = torch.randperm(batch_size) if self.cuda: images, labels, captions = images.cuda(), labels.cuda(), captions.cuda() lbl_real, lbl_fake = lbl_real.cuda(), lbl_fake.cuda() noise = noise.cuda() rnd_perm1, rnd_perm2, rnd_perm3, rnd_perm4 = rnd_perm1.cuda(), rnd_perm2.cuda(), rnd_perm3.cuda(), rnd_perm4.cuda() ############### Update NetD ############### self.netD.zero_grad() # train with wrong image, wrong label, real caption outD_wrong, outC_wrong = self.netD(images[rnd_perm1], captions[rnd_perm2]) # lossD_wrong = self.bce_loss(outD_wrong, lbl_fake) lossD_wrong = self.bce_loss(outD_wrong, lbl_fake) + self.mse_loss(outD_wrong, lbl_fake) lossC_wrong = self.bce_loss(outC_wrong, labels[rnd_perm1]) # train with real image, real label, real caption outD_real, outC_real = self.netD(images, captions) #lossD_real = self.bce_loss(outD_real, lbl_real) lossD_real = self.bce_loss(outD_real, lbl_real) + self.mse_loss(outD_real, lbl_real) lossC_real = self.bce_loss(outC_real, labels) # train with fake image, real label, real caption fake = self.netG(noise, captions) outD_fake, outC_fake = self.netD(fake.detach(), captions[rnd_perm3]) #lossD_fake = self.bce_loss(outD_fake, lbl_fake) lossD_fake = self.bce_loss(outD_fake, lbl_fake) + self.mse_loss(outD_fake, lbl_fake) lossC_fake = self.bce_loss(outC_fake, labels[rnd_perm3]) # backward and forwad for NetD netD_loss = lossC_wrong+lossC_real+lossC_fake + lossD_wrong+lossD_real+lossD_fake netD_loss.backward() self.optimizerD.step() ########## Update NetG ########## # train with fake data self.netG.zero_grad() noise.data.normal_(0,1) # normalize the noise vector fake = self.netG(noise, captions[rnd_perm4]) d_fake, c_fake = self.netD(fake, captions[rnd_perm4]) #lossD_fake_G = self.bce_loss(d_fake, lbl_real) lossD_fake_G = self.mse_loss(d_fake, lbl_real) lossC_fake_G = self.bce_loss(c_fake, labels[rnd_perm4]) netG_loss = lossD_fake_G + lossC_fake_G netG_loss.backward() self.optimizerG.step() netd_loss_sum += netD_loss.item() netg_loss_sum += netG_loss.item() ### print progress info ### print('Epoch %d/%d, %.2f%% completed. Loss_NetD: %.4f, Loss_NetG: %.4f' %(epoch, self.epochs,(float(i)/len(self.trainset_loader))*100, netD_loss.item(), netG_loss.item())) end_time = time() netd_avg_loss = netd_loss_sum / len(self.trainset_loader) netg_avg_loss = netg_loss_sum / len(self.trainset_loader) epoch_time = (end_time-start_time)/60 log_msg = '-------------------------------------------\n' log_msg += 'Epoch %d took %.2f minutes\n'%(epoch, epoch_time) log_msg += 'NetD average loss: %.4f, NetG average loss: %.4f\n\n' %(netd_avg_loss, netg_avg_loss) print(log_msg) with open(os.path.join(self.save_dir, 'training_log.txt'),'a') as log_file: log_file.write(log_msg) return netd_avg_loss, netg_avg_loss # eval epoch def evalEpoch(self, epoch): #self.netD.eval() #self.netG.eval() return 0 # draws and saves the loss graph upto the current epoch def saveGraph(self, netd_losses, netg_losses): plt.plot(netd_losses, color='red', label='NetD Loss') plt.plot(netg_losses, color='blue', label='NetG Loss') plt.xlabel('epoch') plt.ylabel('error') plt.legend(loc='best') plt.savefig(os.path.join(self.save_dir,'loss_graph.png')) plt.close() # save after each epoch def saveCheckpoints(self, epoch): if epoch%self.save_after==0: name_netD = "netd_checkpoints/netD_" + self.save_prefix + "_epoch_" + str(epoch) + ".pth" name_netG = "netg_checkpoints/netG_" + self.save_prefix + "_epoch_" + str(epoch) + ".pth" torch.save(self.netD.module.state_dict(), os.path.join(self.save_dir, name_netD)) torch.save(self.netG.module.state_dict(), os.path.join(self.save_dir, name_netG)) print("Checkpoints for epoch %d saved successfuly" %(epoch)) # SAVE: data parallel model => add .module # LOAD: create model and load checkpoints(not add .module) and wrap nn.DataParallel # this is for fitting prefix # load checkpoints to continue training def loadCheckpoints(self): name_netD = "netd_checkpoints/netD_" + self.save_prefix + "_epoch_" + str(self.continue_epoch) + ".pth" name_netG = "netg_checkpoints/netG_" + self.save_prefix + "_epoch_" + str(self.continue_epoch) + ".pth" self.netG.load_state_dict(torch.load(os.path.join(self.save_dir, name_netG))) self.netD.load_state_dict(torch.load(os.path.join(self.save_dir, name_netD))) print("Checkpoints loaded successfuly")
from torch.autograd import Variable import numpy as np import torchvision.transforms as transforms from PIL import Image nz = 100 cl = 10 bs = 1 transform = transforms.Compose([ transforms.ToPILImage(), ]) labels_list = [np.random.randint(0, 10)] noise = Variable(torch.rand(bs, nz)) onehot_labels = np.zeros((bs, cl)) onehot_labels[np.arange(bs), labels_list] = 1 onehot_labels = Variable( torch.from_numpy(onehot_labels).type(torch.FloatTensor)) noise = torch.cat([noise, onehot_labels], 1) noise = noise.view(bs, nz + cl, 1, 1) netG = NetG(nz + cl) netG.load_state_dict( torch.load('checkpoints/netG__epoch_25.pth', map_location=lambda storage, loc: storage)) output = netG(noise) imgs = transform(output[0].data) print('class: ' + str(labels_list[0])) imgs.show()
torchvision.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]) dataset = torchvision.datasets.ImageFolder(opt.data_path, transform=transforms) dataloader = torch.utils.data.DataLoader( dataset=dataset, batch_size=opt.batchSize, shuffle=True, drop_last=True, ) netG = NetG(opt.ngf, opt.nz).to(device) netD = NetD(opt.ndf).to(device) netD.load_state_dict(torch.load("imgs/netD_007.pth")) netG.load_state_dict(torch.load("imgs/netG_007.pth")) criterion = nn.BCELoss() optimizerG = torch.optim.Adam(netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) optimizerD = torch.optim.Adam(netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) label = torch.FloatTensor(opt.batchSize) real_label = 1 fake_label = 0 for epoch in range(8, opt.epoch + 1): for i, (imgs, _) in enumerate(dataloader): # 固定生成器G,训练鉴别器D
state_epoch = args.resume_epoch optimizerG = torch.optim.Adam(netG.parameters(), lr=0.0001, betas=(0.0, 0.9)) optimizerD_enc = torch.optim.Adam(netD.feature_encoder.parameters(), lr=0.0004, betas=(0.0, 0.9)) optimizerD_proj = torch.optim.Adam(netD.COND_DNET.parameters(), lr=0.004, betas=(0.0, 0.9)) if state_epoch != 0: netG.load_state_dict( torch.load('%s/models/netG_%03d.pth' % (output_dir, state_epoch), map_location='cpu')) netD.load_state_dict( torch.load('%s/models/netD_%03d.pth' % (output_dir, state_epoch), map_location='cpu')) netG = netG.cuda() netD = netD.cuda() optimizerG.load_state_dict( torch.load('%s/models/optimizerG.pth' % (output_dir))) optimizerD.load_state_dict( torch.load('%s/models/optimizerD.pth' % (output_dir))) netG.cuda() netD.cuda() if cfg.B_VALIDATION:
class AnoGAN: """AnoGAN Class """ def __init__(self, opt): # super(AnoGAN, self).__init__(opt, dataloader) # Initalize variables. self.opt = opt self.niter = self.opt.niter self.start_iter = 0 self.netd_niter = 5 self.test_iter = 100 self.lr = self.opt.lr self.batchsize = {'train': self.opt.batchsize, 'test': 1} self.pretrained = False self.phase = 'train' self.outf = self.opt.experiment_group self.algorithm = 'wgan' # LOAD DATA SET self.dataloader = { 'train': provider('train', opt.category, batch_size=self.batchsize['train'], num_workers=4), 'test': provider('test', opt.category, batch_size=self.batchsize['test'], num_workers=4) } self.trn_dir = os.path.join(self.outf, self.opt.experiment_name, 'train') self.tst_dir = os.path.join(self.outf, self.opt.experiment_name, 'test') self.test_img_dir = os.path.join(self.outf, self.opt.experiment_name, 'test', 'images') if not os.path.isdir(self.test_img_dir): os.makedirs(self.test_img_dir) self.best_test_dir = os.path.join(self.outf, self.opt.experiment_name, 'test', 'best_images') if not os.path.isdir(self.best_test_dir): os.makedirs(self.best_test_dir) self.weight_dir = os.path.join(self.trn_dir, 'weights') if not os.path.exists(self.weight_dir): os.makedirs(self.weight_dir) # -- Misc attributes self.epoch = 0 self.l_con = l1_loss self.l_enc = l2_loss ## # Create and initialize networks. self.netg = NetG().cuda() self.netd = NetD().cuda() # Setup optimizer self.optimizer_d = optim.RMSprop(self.netd.parameters(), lr=self.lr) self.optimizer_g = optim.Adam(self.netg.parameters(), lr=self.lr) ## self.weight_path = os.path.join(self.outf, self.opt.experiment_name, 'train', 'weights') if os.path.exists(self.weight_path) and len( os.listdir(self.weight_path)) == 2: print("Loading pre-trained networks...\n") self.netg.load_state_dict( torch.load(os.path.join(self.weight_path, 'netG.pth'))['state_dict']) self.netd.load_state_dict( torch.load(os.path.join(self.weight_path, 'netD.pth'))['state_dict']) self.optimizer_g.load_state_dict( torch.load(os.path.join(self.weight_path, 'netG.pth'))['optimizer']) self.optimizer_d.load_state_dict( torch.load(os.path.join(self.weight_path, 'netD.pth'))['optimizer']) self.start_iter = torch.load( os.path.join(self.weight_path, 'netG.pth'))['epoch'] ## def start(self): """ Train the model """ ## # TRAIN # self.total_steps = 0 best_criterion = -1 #float('inf') best_auc = -1 # Train for niter epochs. # print(">> Training model %s." % self.name) for self.epoch in range(self.start_iter, self.niter): # Train for one epoch mean_wass = self.train() (auc, res, best_rec, best_threshold), res_total = self.test() message = '' # message += 'criterion: (%.3f+%.3f)/2=%.3f ' % (best_rec[0], best_rec[1], res) # message += 'best threshold: %.3f ' % best_threshold message += 'Wasserstein Distance:%.3d ' % mean_wass message += 'AUC: %.3f ' % auc print(message) torch.save( { 'epoch': self.epoch + 1, 'state_dict': self.netg.state_dict(), 'optimizer': self.optimizer_g.state_dict() }, '%s/netG.pth' % (self.weight_dir)) torch.save( { 'epoch': self.epoch + 1, 'state_dict': self.netd.state_dict(), 'optimizer': self.optimizer_d.state_dict() }, '%s/netD.pth' % (self.weight_dir)) if auc > best_auc: best_auc = auc new_message = "******** New optimal found, saving state ********" message = message + '\n' + new_message print(new_message) for img in os.listdir(self.best_test_dir): os.remove(os.path.join(self.best_test_dir, img)) for img in os.listdir(self.test_img_dir): shutil.copyfile(os.path.join(self.test_img_dir, img), os.path.join(self.best_test_dir, img)) shutil.copyfile('%s/netG.pth' % (self.weight_dir), '%s/netg_best.pth' % (self.weight_dir)) log_name = os.path.join(self.outf, self.opt.experiment_name, 'loss_log.txt') message = 'Epoch%3d:' % self.epoch + ' ' + message with open(log_name, "a") as log_file: if self.epoch == 0: log_file.write('\n\n') log_file.write('%s\n' % message) print(">> Training %s Done..." % self.opt.experiment_name) ## def train(self): """ Train the model for one epoch. """ print("\n>>> Epoch %d/%d, Running " % (self.epoch + 1, self.niter) + self.opt.experiment_name) self.netg.train() self.netd.train() # for p in self.netg.parameters(): p.requires_grad = True mean_wass = 0 tk0 = tqdm(self.dataloader['train'], total=len(self.dataloader['train'])) for i, itr in enumerate(tk0): input, _ = itr input = input.cuda() wasserstein_d = None # if self.algorithm == 'wgan': # train NetD for _ in range(self.netd_niter): # for p in self.netd.parameters(): p.requires_grad = True self.optimizer_d.zero_grad() # forward_g latent_i = torch.rand(self.batchsize['train'], 64, 1, 1).cuda() fake = self.netg(latent_i) # forward_d _, pred_real = self.netd(input) _, pred_fake = self.netd(fake) # .detach() TODO # Backward-pass wasserstein_d = (pred_fake.mean() - pred_real.mean()) * 1 wasserstein_d.backward() self.optimizer_d.step() for p in self.netd.parameters(): p.data.clamp_(-0.01, 0.01) #<<<<<<< # train netg # for p in self.netd.parameters(): p.requires_grad = False self.optimizer_g.zero_grad() noise = torch.rand(self.batchsize['train'], 64, 1, 1).cuda() fake = self.netg(noise) _, pred_fake = self.netd(fake) err_g_d = -pred_fake.mean() # negative err_g_d.backward() self.optimizer_g.step() errors = { 'loss_netD': wasserstein_d.item(), 'loss_netG': round(err_g_d.item(), 3), } mean_wass += wasserstein_d.item() tk0.set_postfix(errors) if i % 50 == 0: img_dir = os.path.join(self.outf, self.opt.experiment_name, 'train', 'images') if not os.path.isdir(img_dir): os.makedirs(img_dir) self.save_image_cv2(input.data, '%s/reals.png' % img_dir) self.save_image_cv2(fake.data, '%s/fakes%03d.png' % (img_dir, i)) mean_wass /= len(self.dataloader['train']) return mean_wass ## def test(self): """ Test AnoGAN model. Args: dataloader ([type]): Dataloader for the test set Raises: IOError: Model weights not found. """ self.netg.eval() self.netd.eval() # for p in self.netg.parameters(): p.requires_grad = False # for p in self.netd.parameters(): p.requires_grad = False for img in os.listdir(self.test_img_dir): os.remove(os.path.join(self.test_img_dir, img)) self.phase = 'test' meter = Meter_AnoGAN() tk1 = tqdm(self.dataloader['test'], total=len(self.dataloader['test'])) for i, itr in enumerate(tk1): input, target = itr input = input.cuda() latent_i = torch.rand(self.batchsize['test'], 64, 1, 1).cuda() latent_i.requires_grad = True optimizer_latent = optim.Adam([latent_i], lr=self.lr) test_loss = None for _ in range(self.test_iter): optimizer_latent.zero_grad() fake = self.netg(latent_i) residual_loss = self.l_con(input, fake) latent_o, _ = self.netd(fake) discrimination_loss = self.l_enc(latent_i, latent_o) alpha = 0.1 test_loss = ( 1 - alpha) * residual_loss + alpha * discrimination_loss test_loss.backward() optimizer_latent.step() abnormal_score = test_loss meter.update(abnormal_score, target) #<<<TODO # Save test images. combine = torch.cat([input.cpu(), fake.cpu()], dim=0) self.save_image_cv2(combine, '%s/%05d.jpg' % (self.test_img_dir, i + 1)) criterion, res_total = meter.get_metrics() # rename images for i, res in enumerate(res_total): os.rename('%s/%05d.jpg' % (self.test_img_dir, i + 1), '%s/%05d_%s.jpg' % (self.test_img_dir, i + 1, res)) return criterion, res_total @staticmethod def save_image_cv2(tensor, filename): # return from torchvision.utils import make_grid # tensor = (tensor + 1) / 2 grid = make_grid(tensor, 8, 2, 0, False, None, False) ndarray = grid.mul_(255).clamp_(0, 255).permute(1, 2, 0).to( 'cpu', torch.uint8).numpy() cv2.imwrite(filename, ndarray)
def train(**kwargs): # 读取参数赋值 for k_, v_ in kwargs.items(): setattr(opt, k_, v_) # 可视化 if opt.vis: from visualize import Visualizer vis = Visualizer(opt.env) # 对图片进行操作 transforms = tv.transforms.Compose([ tv.transforms.Scale(opt.image_size), tv.transforms.CenterCrop(opt.image_size), tv.transforms.ToTensor(), # 均值方差 tv.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # ImageFolder 使用pytorch原生的方法读取图片,并进行操作 封装数据集 dataset = tv.datasets.ImageFolder(opt.data_path, transform=transforms) #数据加载器 dataloader = t.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True) # 定义网络 netg, netd = NetG(opt), NetD(opt) # 把map内容加载到CPU中 map_location = lambda storage, loc: storage # 将预训练的模型都先加载到cpu上 if opt.netd_path: netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) if opt.netg_path: netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) # 定义优化器和损失 optimizer_g = t.optim.Adam(netg.parameters(), opt.lr1, betas=(opt.beta1, 0.999)) optimizer_d = t.optim.Adam(netd.parameters(), opt.lr2, betas=(opt.beta1, 0.999)) # BinaryCrossEntropy二分类交叉熵,常用于二分类问题,当然也可以用于多分类问题 criterion = t.nn.BCELoss() # 真图片label为1,假图片label为0 # noises为生成网络的输入 true_labels = Variable(t.ones(opt.batch_size)) fake_labels = Variable(t.zeros(opt.batch_size)) # fix_noises是固定值,用来查看每个epoch的变化效果 fix_noises = Variable(t.randn(opt.batch_size, opt.nz, 1, 1)) noises = Variable(t.randn(opt.batch_size, opt.nz, 1, 1)) # AverageValueMeter统计任意添加的变量的方差和均值 可视化的仪表盘 errord_meter = AverageValueMeter() errorg_meter = AverageValueMeter() if opt.gpu: # 网络转移到GPU netd.cuda() netg.cuda() # 损失函数转移到GPU criterion.cuda() # 标签转移到GPU true_labels, fake_labels = true_labels.cuda(), fake_labels.cuda() # 输入噪声转移到GPU fix_noises, noises = fix_noises.cuda(), noises.cuda() epochs = range(opt.max_epoch) for epoch in iter(epochs): for ii, (img, _) in tqdm.tqdm(enumerate(dataloader)): real_img = Variable(img) if opt.gpu: real_img = real_img.cuda() # 每d_every个batch训练判别器 if ii % opt.d_every == 0: # 训练判别器 optimizer_d.zero_grad() ## 尽可能的把真图片判别为正确 #一个batchd的真照片判定为1 并反向传播 output = netd(real_img) error_d_real = criterion(output, true_labels) #反向传播 error_d_real.backward() ## 尽可能把假图片判别为错误 # 一个batchd的假照片判定为0 并反向传播 noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises).detach() # 根据噪声生成假图 output = netd(fake_img) error_d_fake = criterion(output, fake_labels) error_d_fake.backward() #更新可学习参数 optimizer_d.step() # 总误差=识别真实图片误差+假图片误差 error_d = error_d_fake + error_d_real # 将总误差加入仪表板用于可视化显示 errord_meter.add(error_d.data[0]) # 每g_every个batch训练生成器 if ii % opt.g_every == 0: # 训练生成器 optimizer_g.zero_grad() noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) # 生成器:噪声生成假图片 fake_img = netg(noises) # 判别器:假图片判别份数 output = netd(fake_img) # 尽量让假图片的份数与真标签接近,让判别器分不出来 error_g = criterion(output, true_labels) error_g.backward() # 更新参数 optimizer_g.step() # 将误差加入仪表板用于可视化显示 errorg_meter.add(error_g.data[0]) if opt.vis and ii % opt.plot_every == opt.plot_every - 1: ## 可视化 # 进入debug模式 if os.path.exists(opt.debug_file): ipdb.set_trace() # 固定噪声生成假图片 fix_fake_imgs = netg(fix_noises) # 可视化 固定噪声产生的假图片 vis.images(fix_fake_imgs.data.cpu().numpy()[:64] * 0.5 + 0.5, win='fixfake') # 可视化一张真图片。作为对比 vis.images(real_img.data.cpu().numpy()[:64] * 0.5 + 0.5, win='real') # 可视化仪表盘 判别器误差 生成器误差 vis.plot('errord', errord_meter.value()[0]) vis.plot('errorg', errorg_meter.value()[0]) # 每decay_every个epoch之后保存一次模型 if epoch % opt.decay_every == 0: # 保存模型、图片 tv.utils.save_image(fix_fake_imgs.data[:64], '%s/%s.png' % (opt.save_path, epoch), normalize=True, range=(-1, 1)) # 保存判别器 生成器 t.save(netd.state_dict(), 'checkpoints/netd_%s.pth' % epoch) t.save(netg.state_dict(), 'checkpoints/netg_%s.pth' % epoch) # 清空误差仪表盘 errord_meter.reset() errorg_meter.reset() # 重置优化器参数为刚开始的参数 optimizer_g = t.optim.Adam(netg.parameters(), opt.lr1, betas=(opt.beta1, 0.999)) optimizer_d = t.optim.Adam(netd.parameters(), opt.lr2, betas=(opt.beta1, 0.999))
def main(args): # manualSeed to control the noise manualSeed = 100 random.seed(manualSeed) np.random.seed(manualSeed) torch.manual_seed(manualSeed) with open(args.json_file, 'r') as f: dataset_json = json.load(f) # load rnn encoder text_encoder = RNN_ENCODER(dataset_json['n_words'], nhidden=dataset_json['text_embed_dim']) text_encoder_dir = args.rnn_encoder state_dict = torch.load(text_encoder_dir, map_location=lambda storage, loc: storage) text_encoder.load_state_dict(state_dict) # load netG state_dict = torch.load(args.model_path, map_location=torch.device('cpu')) # netG = NetG(int(dataset_json['n_channels']), int(dataset_json['cond_dim'])) netG = NetG(64, int(dataset_json['cond_dim'])) new_state_dict = OrderedDict() for k, v in state_dict.items(): name = k[7:] # remove `module.`nvidia new_state_dict[name] = v model_dict = netG.state_dict() pretrained_dict = {k: v for k, v in new_state_dict.items() if k in model_dict} model_dict.update(pretrained_dict) netG.load_state_dict(model_dict) # use gpu or not, change model to evaluation mode if args.use_gpu: text_encoder.cuda() netG.cuda() caption_idx.cuda() caption_len.cuda() noise.cuda() text_encoder.eval() netG.eval() # generate noise num_noise = 100 noise = torch.FloatTensor(num_noise, 100) # cub bird captions # caption = 'this small bird has a light yellow breast and brown wings' # caption = 'this small bird has a short beak a light gray breast a darker gray crown and black wing tips' # caption = 'this small bird has wings that are gray and has a white belly' # caption = 'this bird has a yellow throat belly abdomen and sides with lots of brown streaks on them' # caption = 'this little bird has a yellow belly and breast with a gray wing with white wingbars' # caption = 'this bird has a white belly and breast wit ha blue crown and nape' # caption = 'a bird with brown and black wings red crown and throat and the bill is short and pointed' # caption = 'this small bird has a yellow crown and a white belly' # caption = 'this bird has a blue crown with white throat and brown secondaries' # caption = 'this bird has wings that are black and has a white belly' # caption = 'a yellow bird has wings with dark stripes and small eyes' # caption = 'a black bird has wings with dark stripes and small eyes' # caption = 'a red bird has wings with dark stripes and small eyes' # caption = 'a white bird has wings with dark stripes and small eyes' # caption = 'a blue bird has wings with dark stripes and small eyes' # caption = 'a pink bird has wings with dark stripes and small eyes' # caption = 'this is a white and grey bird with black wings and a black stripe by its eyes' # caption = 'a small bird with an orange bill and grey crown and breast' # caption = 'a small bird with black gray and white wingbars' # caption = 'this bird is white and light orange in color with a black beak' # caption = 'a small sized bird that has tones of brown and a short pointed bill' # beak? # MS coco captions # caption = 'two men skiing down a snow covered mountain in the evening' # caption = 'a man walking down a grass covered mountain' # caption = 'a close up of a boat on a field under a sunset' # caption = 'a close up of a boat on a field with a clear sky' # caption = 'a herd of black and white cattle standing on a field' # caption = 'a herd of black and white sheep standing on a field' # caption = 'a herd of black and white dogs standing on a field' # caption = 'a herd of brown cattle standing on a field' # caption = 'a herd of black and white cattle standing in a river' # caption = 'some horses in a field of green grass with a sky in the background' # caption = 'some horses in a field of yellow grass with a sky in the background' caption = 'some horses in a field of green grass with a sunset in the background' # convert caption to index caption_idx, caption_len = get_caption_idx(dataset_json, caption) caption_idx = torch.LongTensor(caption_idx) caption_len = torch.LongTensor([caption_len]) caption_idx = caption_idx.view(1, -1) caption_len = caption_len.view(-1) # use rnn encoder to get caption embedding hidden = text_encoder.init_hidden(1) words_embs, sent_emb = text_encoder(caption_idx, caption_len, hidden) # generate fake image noise.data.normal_(0, 1) sent_emb = sent_emb.repeat(num_noise, 1) words_embs = words_embs.repeat(num_noise, 1, 1) with torch.no_grad(): fake_imgs, fusion_mask = netG(noise, sent_emb) # create path to save image, caption and mask cap_number = 10000 main_path = 'result/mani/cap_%s_0_coco_ch64' % (str(cap_number)) img_save_path = '%s/image' % main_path mask_save_path = '%s/mask_' % main_path mkdir_p(img_save_path) for i in range(7): mkdir_p(mask_save_path + str(i)) # save caption as image ixtoword = {v: k for k, v in dataset_json['word2idx'].items()} cap_img = cap2img(ixtoword, caption_idx, caption_len) im = cap_img[0].data.cpu().numpy() im = (im + 1.0) * 127.5 im = im.astype(np.uint8) im = np.transpose(im, (1, 2, 0)) im = Image.fromarray(im) full_path = '%s/caption.png' % main_path im.save(full_path) # save generated images and masks for i in tqdm(range(num_noise)): full_path = '%s/image_%d.png' % (img_save_path, i) im = fake_imgs[i].data.cpu().numpy() im = (im + 1.0) * 127.5 im = im.astype(np.uint8) im = np.transpose(im, (1, 2, 0)) im = Image.fromarray(im) im.save(full_path) for j in range(7): full_path = '%s%1d/mask_%d.png' % (mask_save_path, j, i) im = fusion_mask[j][i][0].data.cpu().numpy() im = im * 255 im = im.astype(np.uint8) im = Image.fromarray(im) im.save(full_path)
from torch.autograd import Variable from PIL import Image import torchvision.transforms as transforms from model import NetG import pickle # convert to PIL Image trans_toPIL = transforms.ToPILImage() # load the model checkpoint_path = 'checkpoints/netG__epoch_100.pth' n_l = 150 n_z = 100 n_c = 128 netG = NetG(n_z=n_z, n_l=n_l, n_c=n_c) netG.load_state_dict( torch.load(checkpoint_path, map_location=lambda storage, loc: storage)) def generate_from_caption(): caption_file = "enc_text.pkl" # load encoded captions train_ids = pickle.load(open(caption_file, 'rb')) num_captions = len(train_ids['features']) num_images = 2 # create random noise #create random caption skv = Variable(torch.randn(num_images, 4800)) skv.data.normal_(0, 1.1)
batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True) netg = NetG(opt) netd = NetD(opt) # 加载已有的网络参数 if opt.netd_path: print('Loading netd...', end='') netd.load_state_dict(torch.load(opt.netd_path)) print('Successful!') if opt.netg_path: print('Loading netg...', end='') netg.load_state_dict(torch.load(opt.netg_path)) print('Successful!') optimizer_g = torch.optim.Adam(netg.parameters(), opt.lr_netg, betas=(opt.beta1, 0.999)) optimizer_d = torch.optim.Adam(netd.parameters(), opt.lr_netd, betas=(opt.beta1, 0.999)) criterion = torch.nn.BCELoss() # 真图片 label 为 1,假图片为 0 true_labels = Variable(torch.ones(opt.batch_size)) fake_labels = Variable(torch.zeros(opt.batch_size))
def train(**kwargs): ''' 训练函数 :param kwargs: fire传进来的训练参数 :return: ''' opt.parse(kwargs) for k_,v_ in kwargs.items(): setattr(opt,k_,v_) if opt.vis: vis = Visualizer(opt.env) #step1:数据预处理 transforms = tv.transforms.Compose([ tv.transforms.Resize(opt.image_size), tv.transforms.CenterCrop(opt.image_size), tv.transforms.ToTensor(), tv.transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5)) ]) dataset = tv.datasets.ImageFolder(opt.data_path,transform=transforms) dataloader = t.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True) #step2: 定义网络 netg,netd = NetG(opt),NetD(opt) map_location = lambda storage,loc:storage if opt.netd_path: netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) if opt.netg_path: netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) #定义优化器和损失函数 optimizer_g = t.optim.Adam(netg.parameters(), opt.lrG, betas=(0.5, 0.999)) optimizer_d = t.optim.Adam(netd.parameters(), opt.lrD, betas=(0.5, 0.999)) criterion = t.nn.BCELoss() #真图片label为1,加图片label为0 #noise为网络的输入 true_labels = t.ones(opt.batch_size) fake_labels = t.zeros(opt.batch_size) fix_noises = t.randn(opt.batch_size,opt.nz,1,1) noises = t.randn(opt.batch_size,opt.nz,1,1) errord_meter = AverageValueMeter() errorg_meter = AverageValueMeter() if opt.gpu: device = t.device("cuda:0" if t.cuda.is_available() else "cpu") netd.to(device) netg.to(device) criterion.to(device) true_labels,fake_labels = true_labels.to(device),fake_labels.to(device) fix_noises,noises = fix_noises.to(device),noises.to(device) epochs = range(140) for epoch in iter(epochs): for ii,(img,_) in tqdm.tqdm(enumerate(dataloader),total=len(dataloader)): if opt.gpu: real_img = img.to(device) if ii%opt.d_every == 0: #每个batch训练一次鉴别器 optimizer_d.zero_grad() output = netd(real_img) #判断真图片(使其尽可能大) error_d_real = criterion(output,true_labels) error_d_real.backward() ##尽可能把假图片判断为错误 noises.data.copy_(t.randn(opt.batch_size,opt.nz,1,1)) fake_img = netg(noises).detach() #根据噪声生成假图 output = netd(fake_img) error_d_fake = criterion(output,fake_labels) error_d_fake.backward() optimizer_d.step() error_d = error_d_fake + error_d_real errord_meter.add(error_d.item()) if ii%opt.g_every == 0: #每5个batch更新一次生成器 #训练生成器 optimizer_g.zero_grad() noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises) output = netd(fake_img) error_g = criterion(output,true_labels) error_g.backward() optimizer_g.step() errord_meter.add(error_g.item()) if opt.vis and ii%opt.plot_time == opt.plot_time - 1: ##可视化 fix_fake_img = netg(fix_noises) #使用噪声生成图片 vis.images(fix_fake_img.data.cpu().numpy()[:64]*0.5+0.5,win = 'fixfake') # vis.images(real_img.data.cpu().numpy()[:64]*0.5+0.5,win = 'real') vis.plot('errord', errord_meter.value()[0]) vis.plot('errorg', errorg_meter.value()[0]) if epoch%opt.decay_every == opt.decay_every-1: #保存模型,图片 tv.utils.save_image(fix_fake_img.data[:64],'%s/new%s.png'%(opt.save_path,epoch), normalize=True,range=(-1,1)) t.save(netd.state_dict(), 'checkpoints/new_netd_%s.pth' % epoch) t.save(netg.state_dict(), 'checkpoints/new_netg_%s.pth' % epoch) errord_meter.reset() errorg_meter.reset() optimizer_g = t.optim.Adam(netg.parameters(), opt.lrG, betas=(0.5, 0.999)) optimizer_d = t.optim.Adam(netd.parameters(), opt.lrD, betas=(0.5, 0.999))
def train(**kwargs): for k_, v_ in kwargs.items(): setattr(opt, k_, v_) device = t.device('cuda') if opt.gpu else t.device('cpu') # if opt.vis: # from visualize import Visualizer # vis = Visualizer(opt.env) # 数据 transforms = tv.transforms.Compose([ tv.transforms.Resize(opt.image_size), tv.transforms.CenterCrop(opt.image_size), tv.transforms.ToTensor(), tv.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) dataset = tv.datasets.ImageFolder(root=opt.data_path, transform=transforms) dataloader = t.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True) # 网络 netg, netd = NetG(opt), NetD(opt) map_location = lambda storage, loc: storage if opt.netd_path: netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) if opt.netg_path: netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) netd.to(device) netg.to(device) # 定义优化器和损失 optimizer_g = t.optim.Adam(netg.parameters(), opt.lr1, betas=(opt.beta1, 0.999)) optimizer_d = t.optim.Adam(netd.parameters(), opt.lr2, betas=(opt.beta1, 0.999)) criterion = t.nn.BCELoss().to(device) # 真图片label为1,假图片label为0 # noises为生成网络的输入 true_labels = t.ones(opt.batch_size).to(device) fake_labels = t.zeros(opt.batch_size).to(device) fix_noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device) noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device) errord_meter = AverageValueMeter() errorg_meter = AverageValueMeter() epochs = range(opt.max_epoch) for epoch in iter(epochs): for ii, (img, _) in tqdm.tqdm(enumerate(dataloader)): real_img = img.to(device) if ii % opt.d_every == 0: # 训练判别器 optimizer_d.zero_grad() ## 尽可能的把真图片判别为正确 output = netd(real_img) error_d_real = criterion(output, true_labels) error_d_real.backward() ## 尽可能把假图片判别为错误 noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises).detach() # 根据噪声生成假图 output = netd(fake_img) error_d_fake = criterion(output, fake_labels) error_d_fake.backward() optimizer_d.step() error_d = error_d_fake + error_d_real errord_meter.add(error_d.item()) if ii % opt.g_every == 0: # 训练生成器 optimizer_g.zero_grad() noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises) output = netd(fake_img) error_g = criterion(output, true_labels) error_g.backward() optimizer_g.step() errorg_meter.add(error_g.item()) if opt.vis and ii % opt.plot_every == opt.plot_every - 1: ## 可视化 if os.path.exists(opt.debug_file): ipdb.set_trace() fix_fake_imgs = netg(fix_noises) vis.images(fix_fake_imgs.detach().cpu().numpy()[:64] * 0.5 + 0.5, win='fixfake') vis.images(real_img.data.cpu().numpy()[:64] * 0.5 + 0.5, win='real') vis.plot('errord', errord_meter.value()[0]) vis.plot('errorg', errorg_meter.value()[0]) if (epoch + 1) % opt.save_every == 0: # 保存模型、图片 tv.utils.save_image(fix_fake_imgs.data[:64], '%s/%s.png' % (opt.save_path, epoch), normalize=True, range=(-1, 1)) t.save(netd.state_dict(), 'checkpoints/netd_%s.pth' % epoch) t.save(netg.state_dict(), 'checkpoints/netg_%s.pth' % epoch) errord_meter.reset() errorg_meter.reset()
z = Variable(z) netG = netG.cuda() netD = netD.cuda() z = z.cuda() realData = realData.cuda() one = one.cuda() mone = mone.cuda() # setup optimizer optimizerD = optim.RMSprop(netD.parameters(), lr=0.00005) # 0.00005 optimizerG = optim.RMSprop(netG.parameters(), lr=0.00005) if opt.ep != -1: netD.load_state_dict( torch.load(checkRoot + '/netD_epoch_' + str(opt.ep) + '.pth')) netG.load_state_dict( torch.load(checkRoot + '/netG_epoch_' + str(opt.ep) + '.pth')) # train ig = 0 for it in np.arange(iterNum) + opt.ep + 1: dataIter = iter(dataLoader) ib = 0 while ib < len(dataLoader): ############################ # (1) Update D network ########################### # train the discriminator Diters times if ig < 25 or ig % 500 == 0: Diters = 10 else: Diters = 5 id = 0
from my_dataSet import CASIABDatasetGenerate netg = NetG(nc=1) netd = NetD(nc=1) neta = NetA(nc=1) device = th.device("cuda:0") netg = netg.to(device) netd = netd.to(device) neta = neta.to(device) fineSize = 64 checkpoint = '/home/mg/code/my_GAN_dataSet/snapshots/snapshot_449.t7' checkpoint = th.load(checkpoint) neta.load_state_dict(checkpoint['netA']) netg.load_state_dict(checkpoint['netG']) netd.load_state_dict(checkpoint['netD']) neta.eval() netg.eval() netd.eval() angles = [ '000', '018', '036', '054', '072', '090', '108', '126', '144', '162', '180' ] for cond in ['nm-01', 'nm-02', 'nm-03', 'nm-04', 'cl-01', 'cl-02']: dataset = CASIABDatasetGenerate( data_dir='/home/mg/code/data/GEI_CASIA_B/gei/', cond=cond) for i in range(1, 125): ass_label, img = dataset.getbatch(i, 11) img = img.to(device).to(th.float32)
def train(): # change opt # for k_, v_ in kwargs.items(): # setattr(opt, k_, v_) device = torch.device('cuda') if torch.cuda.is_available else torch.device( 'cpu') if opt.vis: from visualizer import Visualizer vis = Visualizer(opt.env) # rescale to -1~1 transform = transforms.Compose([ transforms.Resize(opt.image_size), transforms.CenterCrop(opt.image_size), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) dataset = datasets.ImageFolder(opt.data_path, transform=transform) dataloader = DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True) netd = NetD(opt) netg = NetG(opt) map_location = lambda storage, loc: storage if opt.netd_path: netd.load_state_dict(torch.load(opt.netd_path), map_location=map_location) if opt.netg_path: netg.load_state_dict(torch.load(opt.netg_path), map_location=map_location) if torch.cuda.is_available(): netd.to(device) netg.to(device) # 定义优化器和损失 optimizer_g = torch.optim.Adam(netg.parameters(), opt.lr1, betas=(opt.beta1, 0.999)) optimizer_d = torch.optim.Adam(netd.parameters(), opt.lr2, betas=(opt.beta1, 0.999)) criterion = torch.nn.BCELoss().to(device) # 真label为1, noises是输入噪声 true_labels = Variable(torch.ones(opt.batch_size)) fake_labels = Variable(torch.zeros(opt.batch_size)) fix_noises = Variable(torch.randn(opt.batch_size, opt.nz, 1, 1)) noises = Variable(torch.randn(opt.batch_size, opt.nz, 1, 1)) errord_meter = AverageValueMeter() errorg_meter = AverageValueMeter() if torch.cuda.is_available(): netd.cuda() netg.cuda() criterion.cuda() true_labels, fake_labels = true_labels.cuda(), fake_labels.cuda() fix_noises, noises = fix_noises.cuda(), noises.cuda() for epoch in range(opt.max_epoch): print("epoch:", epoch, end='\r') # sys.stdout.flush() for ii, (img, _) in enumerate(dataloader): real_img = Variable(img) if torch.cuda.is_available(): real_img = real_img.cuda() # 训练判别器, real -> 1, fake -> 0 if (ii + 1) % opt.d_every == 0: # real optimizer_d.zero_grad() output = netd(real_img) # print(output.shape, true_labels.shape) error_d_real = criterion(output, true_labels) error_d_real.backward() # fake noises.data.copy_(torch.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises).detach() # 随机噪声生成假图 fake_output = netd(fake_img) error_d_fake = criterion(fake_output, fake_labels) error_d_fake.backward() # update optimizer optimizer_d.step() error_d = error_d_fake + error_d_real errord_meter.add(error_d.item()) # 训练生成器, 让生成器得到的图片能够被判别器判别为真 if (ii + 1) % opt.g_every == 0: optimizer_g.zero_grad() noises.data.copy_(torch.randn(opt.batch_size, opt.nz, 1, 1)) fake_img = netg(noises) fake_output = netd(fake_img) error_g = criterion(fake_output, true_labels) error_g.backward() optimizer_g.step() errorg_meter.add(error_g.item()) if opt.vis and ii % opt.plot_every == opt.plot_every - 1: # 进行可视化 # if os.path.exists(opt.debug_file): # import ipdb # ipdb.set_trace() fix_fake_img = netg(fix_noises) vis.images( fix_fake_img.detach().cpu().numpy()[:opt.batch_size] * 0.5 + 0.5, win='fixfake') vis.images(real_img.data.cpu().numpy()[:opt.batch_size] * 0.5 + 0.5, win='real') vis.plot('errord', errord_meter.value()[0]) vis.plot('errorg', errorg_meter.value()[0]) if (epoch + 1) % opt.save_every == 0: # 保存模型、图片 tv.utils.save_image(fix_fake_img.data[:opt.batch_size], '%s/%s.png' % (opt.save_path, epoch), normalize=True, range=(-1, 1)) torch.save(netd.state_dict(), 'checkpoints/netd_%s.pth' % epoch) torch.save(netg.state_dict(), 'checkpoints/netg_%s.pth' % epoch) errord_meter.reset() errorg_meter.reset()