def generate(**kwargs): """ 随机生成图像,并根据netd的分数选择较好的 """ with t.no_grad(): opt._parse(kwargs) 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(opt._parse(kwargs)) 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(opt._parse(kwargs)) netg.to(opt._parse(kwargs)) # 生成图片,并计算图片在判别器的分数 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): """用训练好的数据进行生成图片""" for k_, v_ in kwargs.items(): setattr(opt, k_, v_) device = t.device("cuda" if opt.gpu else "cpu") # 1.加载训练好权重数据 netg, netd = NetG(opt).eval(), NetD(opt).eval() map_location = lambda storage, loc: storage netd.load_state_dict(t.load(opt.netd_path, map_location=map_location), False) netg.load_state_dict(t.load(opt.netg_path, map_location=map_location), False) netd.to(device) netg.to(device) # 2.生成训练好的图片 noise = t.randn(opt.gen_search_num, opt.nz, 1, 1).normal_(opt.gen_mean, opt.gen_std) noise.to(device) fake_image = netg(noise) score = netd(fake_image).detach() # TODO 查阅topk()函数 # 挑选出合适的图片 indexs = score.topk(opt.gen_num)[1] result = [] for ii in indexs: result.append(fake_image.data[ii]) tv.utils.save_image(t.stack(result), opt.gen_img, normalize=True, range=(-1, 1))
def generate(**kwargs): opt.parse(**kwargs) 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) if opt.netd_path: netg.load(opt.netg_path) if opt.netg_path: netd.load(opt.netd_path) if opt.use_gpu: netd.cuda() netg.cuda() noises = noises.cuda() # 生成图片,并计算图片在判别器的分数 fake_img = netg(noises) scores = netd(fake_img).data # 选好的 index = scores.topk(opt.gen_num)[1] result = [] for ii in index: # tensor的截取与合并 cat, stack,cat+view=stack,stack 新增维度进行合并 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_) D = NetD(opt) G = NetG(opt) noises = torch.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 D.load_state_dict(torch.load(opt.netd_path, map_location=map_location)) G.load_state_dict(torch.load(opt.netg_path, map_location=map_location)) if torch.cuda.is_available(): D.cuda() G.cuda() noises = noises.cuda() # 生成图片,并计算图片在判别器的分数 fake_img = G(noises) scores = D(fake_img).data # 挑选最好的某几张 indexs = scores.topk(opt.gen_num)[1] result = [] for idx in indexs: result.append(fake_img.data[idx]) # 保存图片 torchvision.utils.save_image(torch.stack(result), opt.gen_img, normalize=True, range=(-1, 1))
writer = SummaryWriter() opt = Config() transform = transforms.Compose([ transforms.Scale(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 = 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) if opt.netd_path: netd.load_state_dict(torch.load(opt.netd_path, map_location=lambda storage, loc: storage)) if opt.netg_path: netg.load_state_dict(torch.load(opt.netg_path, map_location=lambda storage, loc: storage)) optimizer_g = Adam(netg.parameters(), opt.lr1, betas=(opt.beta1, 0.999)) optimizer_d = Adam(netd.parameters(), opt.lr2, betas=(opt.beta1, 0.999)) criterion = nn.BCELoss() 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))
def train(**kwargs): opt._parse(kwargs) demoer = Evaluator(opt) anime_data = AnimeData(opt.data_path) anime_dataloader = DataLoader(anime_data, batch_size=opt.batch_size, shuffle=True) noise_data = NoiseData(opt.noise_size, len(anime_data)) noise_dataloader = DataLoader(noise_data, batch_size=opt.batch_size, shuffle=True) net_G = NetG(opt) net_D = NetD(opt) if opt.use_gpu: net_G = net_G.cuda() net_D = net_D.cuda() criterion = torch.nn.BCELoss() optimizer_G = torch.optim.Adam(net_G.parameters(), lr=opt.lr_g, betas=(opt.beta1, opt.beta2)) optimizer_D = torch.optim.Adam(net_D.parameters(), lr=opt.lr_d, betas=(opt.beta1, opt.beta2)) loss_D_meteor = meter.AverageValueMeter() loss_G_meteor = meter.AverageValueMeter() if opt.netd_path is not None: net_D.load(opt.netd_path) if opt.netg_path is not None: net_G.load(opt.netg_path) for epoch in range(opt.max_epochs): loss_D_meteor.reset() loss_G_meteor.reset() num_batch = len(anime_dataloader) generator = enumerate(zip(anime_dataloader, noise_dataloader)) for ii, (true_image, feature_map) in tqdm(generator, total=num_batch, ascii=True): num_data = true_image.shape[0] true_targets = torch.ones(num_data) fake_targets = torch.zeros(num_data) if opt.use_gpu: feature_map = feature_map.cuda() true_image = true_image.cuda() true_targets = true_targets.cuda() fake_targets = fake_targets.cuda() # Train discriminator if ii % opt.every_d == 0: optimizer_D.zero_grad() net_G.set_requires_grad(False) net_D.set_requires_grad(True) fake_image = net_G(feature_map) fake_score = net_D(fake_image) true_score = net_D(true_image) loss_D = criterion(fake_score, fake_targets) + \ criterion(true_score, true_targets) loss_D.backward() optimizer_D.step() loss_D_meteor.add(loss_D.detach().item()) if os.path.exists(opt.debug_file): import ipdb ipdb.set_trace() # Train generator if ii % opt.every_g == 0: optimizer_G.zero_grad() net_G.set_requires_grad(True) net_D.set_requires_grad(False) fake_image = net_G(feature_map) fake_score = net_D(fake_image) loss_G = criterion(fake_score, true_targets) loss_G.backward() optimizer_G.step() loss_G_meteor.add(loss_G.detach().item()) if os.path.exists(opt.debug_file): import ipdb ipdb.set_trace() gan_log = "Epoch {epoch:0>2d}: loss_D - {loss_D}, loss_G - {loss_G}".format( epoch=epoch + 1, loss_D=loss_D_meteor.value()[0], loss_G=loss_G_meteor.value()[0], ) print(gan_log) if epoch % opt.save_freq == opt.save_freq - 1: demoer.evaluate(net_G) net_D.save(opt.save_model_path) net_G.save(opt.save_model_path) time.sleep(0.5)
def train(**kwargs): opt._parse(kwargs) if opt.vis: from utils.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 # 最后一个数据集不满batch_size 将被遗弃 ) # 网络 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(opt.device) netg.to(opt.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(opt.device) # 真图片label为1,假图片label为0 # noises为生成网络的输入 true_labels = t.ones(opt.batch_size).to(opt.device) # 真 fake_labels = t.zeros(opt.batch_size).to(opt.device) # 假 fix_noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(opt.device) noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(opt.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(opt.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: ## 可视化 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)) tag = [ i for i in os.listdir('./data') if os.path.isdir('./data/' + i) ][0] t.save(netd.state_dict(), 'checkpoints/%s_d_%s.pth' % (tag, epoch)) t.save(netg.state_dict(), 'checkpoints/%s_g_%s.pth' % (tag, epoch)) errord_meter.reset() errorg_meter.reset()
def train(**kwargs): """training NetWork""" # 0.配置属性 for k_, v_ in kwargs.items(): setattr(opt, k_, v_) device = t.device("cuda") if opt.gpu else t.device("cpu") # 1.预处理数据 transforms = tv.transforms.Compose([ tv.transforms.Resize(opt.img_size), # 3*96*96 tv.transforms.CenterCrop(opt.img_size), tv.transforms.ToTensor(), tv.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # 1.1 加载数据 dataset = tv.datasets.ImageFolder(opt.data_path, transform=transforms) # TODO 复习这个封装方法 dataloader = DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True) # TODO 查看drop_last操作 # 2.初始化网络 netg, netd = NetG(opt), NetD(opt) # 2.1判断网络是否已有权重数值 map_location = lambda storage, loc: storage # TODO 复习map_location操作 if opt.netg_path: netg.load_state_dict(t.load(opt.netg_path, map_location=map_location)) if opt.netd_path: netd.load_state_dict(t.load(opt.netd_path, map_location=map_location)) # 2.2 搬移模型到指定设备 netd.to(device) netg.to(device) # 3. 定义优化策略 # TODO 复习Adam算法 optimize_g = t.optim.Adam(netg.parameters(), lr=opt.lr1, betas=(opt.beta1, 0.999)) optimize_d = t.optim.Adam(netd.parameters(), lr=opt.lr2, betas=(opt.beta1, 0.999)) criterions = nn.BCELoss().to(device) # TODO 重新复习BCELoss方法 # 4. 定义标签, 并且开始注入生成器的输入noise true_labels = t.ones(opt.batch_size).to(device) fake_labels = t.ones(opt.batch_size).to(device) noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device) fix_noises = t.randn(opt.batch_size, opt.nz, 1, 1).to(device) errord_meter = AverageValueMeter() # TODO 重新阅读torchnet errorg_meter = AverageValueMeter() # 6.训练网络 epochs = range(opt.max_epoch) write = SummaryWriter(log_dir=opt.virs, comment='loss') # 6.1 设置迭代 for epoch in iter(epochs): # 6.2 读取每一个batch 数据 for ii_, (img, _) in tqdm.tqdm(enumerate(dataloader)): real_img = img.to(device) # 6.3开始训练生成器和判别器 # 注意要使得生成的训练次数小于一些 if ii_ % opt.d_every == 0: optimize_d.zero_grad() # 训练判别器 # 真图 output = netd(real_img) error_d_real = criterions(output, true_labels) error_d_real.backward() # 随机生成的假图 noises = noises.detach() fake_image = netg(noises).detach() output = netd(fake_image) error_d_fake = criterions(output, fake_labels) error_d_fake.backward() optimize_d.step() # 计算loss error_d = error_d_fake + error_d_real errord_meter.add(error_d.item()) # 训练判别器 if ii_ % opt.g_every == 0: optimize_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 = criterions(output, true_labels) error_g.backward() optimize_g.step() errorg_meter.add(error_g.item()) # 绘制数据 if ii_ % 5 == 0: write.add_scalar("Discriminator_loss", errord_meter.value()[0]) write.add_scalar("Generator_loss", errorg_meter.value()[0]) # 7.保存模型 if (epoch + 1) % opt.save_every == 0: fix_fake_image = netg(fix_noises) tv.utils.save_image(fix_fake_image.data[:64], "%s/%s.png" % (opt.save_path, epoch), normalize=True) 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() write.close()
def train(**kwargs): # step1: configure opt.parse(**kwargs) if opt.vis: vis = Visualizer(opt.env) # step2: data normalize = T.Normalize(mean = [0.5,0.5,0.5], std = [0.5,0.5,0.5] ) transforms = T.Compose( [ T.Resize(opt.image_size), T.CenterCrop(opt.image_size), T.ToTensor(), normalize ]) # 对于这个模型 transform对于train和test没有区别 dataset = tv.datasets.ImageFolder(opt.data_path,transform=transforms) dataloader = DataLoader(dataset, batch_size = opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True) # 加载图片,用于训练NetD模型 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)) # 固定噪声,用于验证NetG模型 noises = Variable(t.randn(opt.batch_size, opt.nz, 1, 1)) # 随机噪声,用于训练和测试NetG模型 # step3: model netg, netd = NetG(opt), NetD(opt) map_location = lambda storage, loc:storage if opt.netg_path: netg.load(opt.netg_path) if opt.netd_path: netd.load(opt.netd_path) # step4: criterion and optimizer optimizer_g = t.optim.Adam(params=netg.parameters(), lr = opt.lrg, betas=(opt.beta1,0.999)) optimizer_d = t.optim.Adam(params=netd.parameters(), lr = opt.lrd, betas=(opt.beta1,0.999)) criterion = t.nn.BCELoss() # step: meters errord_meter = meter.AverageValueMeter() errorg_meter = meter.AverageValueMeter() if opt.use_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() # step5: train for epoch in range(opt.max_epoch): ## step5.1 train for ii,(data, _) in tqdm(enumerate(dataloader)): real_img = Variable(data) if opt.use_gpu: real_img = real_img.cuda() 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() # 假图片 noises.data.copy_(t.randn(opt.batch_size, opt.nz, 1, 1)) # 在第八章的时候想通了这里为什么要加detach,这个detach不是为了防止反向传播传到netg中,因为parameter已经保证了,是为了fake_output的requires_grad设置为False,不对fake_img求导,因为不需要,当然,在后来的实验室中我设置成没有也没有报错,但是这是为了节约内存,已经确定,可以停止反向传播,节约内存,与requires_grad=False的意义一样,但是requires_grad只能用于leaf节点,对于非leaf节点,使其不进行求导的方式是detach() fake_img = netg(noises).detach() fake_output = netd(fake_img) error_d_fake = criterion(fake_output, fake_labels) error_d_fake.backward() optimizer_d.step() error_d = error_d_real+error_d_fake errord_meter.add(error_d.data) 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_meter.add(error_g.data) ## step5.2 validate and visualize on batch_size # 我们可以看到,损失函数并不是一个epoch画一次,而是几个batch画一次 if (ii+1) % opt.print_freq == 0 and opt.vis: if os.path.exists(opt.debug_file): # import ipdb ipdb.set_trace() fix_fake_imgs = netg(fix_noises) # batch_size*nz*1*1 --> batch_size(256)*3*96*96 # 可以认为是在验证模型 vis.img('fix_fake',fix_fake_imgs.data[:64]*0.5+0.5) vis.img('real', real_img.data[:64]*0.5+0.5) vis.plot(win = 'errord',y= errord_meter.value()[0]) vis.plot(win = 'errorg',y= errorg_meter.value()[0]) ## step5.3 validate and save model on epoch # 模型保存是每几个epoch保存一次, # 按理来说模型验证也应该是每次或这每几次验证一次,这一点和这一章的模型验证有所不一样,不过不用太在意,因为这一章的模型验证没有指标。 if (epoch+1)%opt.save_freq == 0: netg.save(opt.model_save_path,'netg_%s' %epoch) netd.save(opt.model_save_path,'netd_%s' %epoch) fix_fake_imgs = val(netg,fix_noises) tv.utils.save_image(fix_fake_imgs,'%s/%s.png' % (opt.img_save_path, epoch),normalize=True, range=(-1,1)) # 和作者沟通后,因为数据集少,所以为了避免每次重置的噪声,多几个epoch再重置,等下试试每次重置的话这个误差的变化情况 errord_meter.reset() errorg_meter.reset() """
def train(**kwargs): for k_, v_ in kwargs.items(): setattr(opt, k_, v_) transforms = torchvision.transforms.Compose([ torchvision.transforms.Resize(opt.image_size), torchvision.transforms.CenterCrop(opt.image_size), torchvision.transforms.ToTensor(), torchvision.transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ]) dataset = torchvision.datasets.ImageFolder(opt.data_path, transform=transforms) dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, drop_last=True) # 1、定义神经网络 D = NetD(opt) G = NetG(opt) map_location = lambda storage, loc: storage if opt.netd_path: D.load_state_dict(torch.load(opt.netd_path, map_location=map_location)) if opt.netg_path: G.load_state_dict(torch.load(opt.netg_path, map_location=map_location)) # 2、定义优化器和损失 d_optim = torch.optim.Adam(D.parameters(), opt.d_learning_rate, betas=(opt.optim_beta1, 0.999)) g_optim = torch.optim.Adam(G.parameters(), opt.g_learning_rate, betas=(opt.optim_beta1, 0.999)) criterion = torch.nn.BCELoss() # 真图片label为1,假图片label为0 real_labels = Variable(torch.ones(opt.batch_size)) fake_labels = Variable(torch.zeros(opt.batch_size)) if torch.cuda.is_available(): D.cuda() G.cuda() criterion.cuda() real_labels, fake_labels = real_labels.cuda(), fake_labels.cuda() # 3、可视化训练过程 for epoch in range(opt.num_epochs): for step, (images, _) in tqdm.tqdm(enumerate(dataloader)): if step % opt.d_every == 0: # 1、训练判别器 d_optim.zero_grad() ## 尽可能的把真图片判别为正确 d_real_data = Variable(images) d_real_data = d_real_data.cuda() if torch.cuda.is_available( ) else d_real_data d_real_decision = D(d_real_data) d_real_error = criterion(d_real_decision, real_labels) d_real_error.backward() ## 尽可能把假图片判别为错误 d_gen_input = Variable( torch.randn(opt.batch_size, opt.nz, 1, 1)) d_gen_input = d_gen_input.cuda() if torch.cuda.is_available( ) else d_gen_input d_fake_data = G(d_gen_input).detach() d_fake_decision = D(d_fake_data) d_fake_error = criterion(d_fake_decision, fake_labels) d_fake_error.backward() d_optim.step( ) # Only optimizes D's parameters; changes based on stored gradients from backward() if step % opt.g_every == 0: # 2、训练生成器 g_optim.zero_grad() ## 尽可能让判别器把假图片判别为正确 g_gen_input = Variable( torch.randn(opt.batch_size, opt.nz, 1, 1)) g_gen_input = g_gen_input.cuda() if torch.cuda.is_available( ) else g_gen_input g_fake_data = G(g_gen_input) g_fake_decision = D(g_fake_data) g_fake_error = criterion(g_fake_decision, real_labels) g_fake_error.backward() g_optim.step() if step % opt.epoch_every == 0: print("%s, %s, D: %s/%s G: %s" % (step, g_fake_decision.cpu().data.numpy().mean(), d_real_error.cpu().data[0], d_fake_error.cpu().data[0], g_fake_error.cpu().data[0])) # 保存模型、图片 torchvision.utils.save_image(g_fake_data.data[:36], '%s/%s.png' % (opt.save_img_path, epoch), normalize=True, range=(-1, 1)) torch.save(D.state_dict(), '%s/netd_%s.pth' % (opt.checkpoints_path, epoch)) torch.save(G.state_dict(), '%s/netg_%s.pth' % (opt.checkpoints_path, epoch))
class Opt(): noise_size = NOISE_SIZE ndf = 64 ngf = 64 opt = Opt() noise_data = NoiseData(NOISE_SIZE, BATCH_SIZE) noise_dataloader = DataLoader(noise_data, batch_size=BATCH_SIZE) noise_iter = iter(noise_dataloader) feature_map = next(noise_iter) net_G = NetG(opt) net_D = NetD(opt) criterion = torch.nn.MSELoss() optimzer = torch.optim.SGD(net_D.parameters(), lr=0.1) # ============================= # # Testing # ============================= # def test_networks(): generated = net_G(feature_map) assert generated.shape == torch.Tensor(BATCH_SIZE, 3, 96, 96).shape assert torch.max(generated) <= 1 assert torch.min(generated) >= 0 res_generated = net_D(generated)
transform = transforms.Compose([ transforms.Scale(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 = 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) if opt.netd_path: netd.load_state_dict( torch.load(opt.netd_path, map_location=lambda storage, loc: storage)) if opt.netg_path: netg.load_state_dict( torch.load(opt.netg_path, map_location=lambda storage, loc: storage)) optimizer_g = Adam(netg.parameters(), opt.lr1, betas=(opt.beta1, 0.999)) optimizer_d = Adam(netd.parameters(), opt.lr2, betas=(opt.beta1, 0.999)) criterion = nn.BCELoss() true_labels = Variable(torch.ones(opt.batch_size))
replacement=False) ulnodeB = np.setdiff1d(np.array([i for i in range(len(labelsB))]), lnodeB.numpy()) np.random.shuffle(ulnodeB) valnodeB = ulnodeB[0:int(0.2 * nB)] ulnodeB = ulnodeB[int(0.2 * nB) + 1:-1] np.random.seed(args.seed) random.seed(args.seed) torch.manual_seed(args.seed) torch.backends.cudnn.deterministic = True torch.backends.cudnn.enabled = False # Model and optimizer mlp = MLP(in_features=args.hidden, nclass=labelsA.max().item() + 1) Dnet = NetD(nhid=args.hidden) model = GCN(nfeat=featuresA.shape[1], nhid=args.hidden, nclass=labelsA.max().item() + 1, dropout=args.dropout) #model.load_state_dict(torch.load('init2.pkl')) #for item in model.parameters(): # print(item) optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) optimizer_mlp = optim.Adam(mlp.parameters(), lr=0.01, weight_decay=args.weight_decay) dis_optimizer = optim.SGD(Dnet.parameters(), lr=args.lr,