def load(self):
save_dir = os.path.join(self.save_dir, self.dataset, self.model_name)
Generator1.load_state_dict(
torch.load(os.path.join(save_dir, self.model_name + '_G.pkl')))
Discriminator1.load_state_dict(
torch.load(os.path.join(save_dir, self.model_name + '_D.pkl')))
def save(self):
save_dir = os.path.join(self.save_dir, self.dataset, self.model_name)
if not os.path.exists(save_dir):
os.makedirs(save_dir)
torch.save(Generator1.state_dict(),
os.path.join(save_dir, self.model_name + '_G.pkl'))
torch.save(Discriminator1.state_dict(),
os.path.join(save_dir, self.model_name + '_D.pkl'))
with open(os.path.join(save_dir, self.model_name + '_history.pkl'),
'wb') as f:
pickle.dump(self.train_hist, f)
def visualize_results(self, epoch, fix=True):
Generator1.eval()
if not os.path.exists(self.result_dir + '/' + self.dataset + '/' +
self.model_name):
os.makedirs(self.result_dir + '/' + self.dataset + '/' +
self.model_name)
image_frame_dim = int(np.floor(np.sqrt(sample_num)))
if fix:
""" fixed noise """
samples = Generator1(self.sample_z_, self.sample_y_)
else:
""" random noise """
sample_y_ = torch.zeros(opt.batch_size, opt.n_classes).scatter_(
1,
torch.randint(0, opt.n_classes - 1,
(opt.batch_size, 1)).type(torch.LongTensor), 1)
sample_z_ = torch.rand((opt.batch_size, opt.latent_dim))
if cuda:
sample_z_, sample_y_ = sample_z_.cuda(), sample_y_.cuda()
samples = Generator1(sample_z_, sample_y_)
if cuda:
samples = samples.cpu().data.numpy().transpose(0, 2, 3, 1)
else:
samples = samples.data.numpy().transpose(0, 2, 3, 1)
samples = (samples + 1) / 2
utils.save_images(
samples[:image_frame_dim * image_frame_dim, :, :, :],
[image_frame_dim, image_frame_dim],
self.result_dir + '/' + self.dataset + '/' + self.model_name +
'/' + self.model_name + '_epoch%03d' % epoch + '.png')
train_dataloader = DataLoader(dataset=DomainData(train_examples,
label_list,
max_seq_length,
tokenizer),
batch_size=batch_size,
shuffle=True,
drop_last=False)
val_dataset = DomainData(val_examples, label_list, max_seq_length,
tokenizer)
val_dataloader = DataLoader(dataset=val_dataset, batch_size=batch_size)
num_train_steps = int(len(train_examples) / batch_size * total_epoch_num)
bert = BertModel.from_pretrained(bert_model, PYTORCH_PRETRAINED_BERT_CACHE)
generator = Generator1(noise_size=noise_size,
output_size=768,
hidden_sizes=[768],
dropout_rate=0.1)
discriminator = Discriminator(input_size=768,
hidden_sizes=[768],
num_labels=len(label_list),
dropout_rate=0.1)
bert.to(device)
if multi_gpu:
bert = torch.nn.DataParallel(bert, device_ids=device_ids)
generator.to(device)
discriminator.to(device)
param_optimizer = list(bert.named_parameters())
no_decay = ['bias', 'gamma', 'beta']
# Initialize generator and discriminator
if opt.arch == 'mlp':
if opt.gan_type == 'cgan':
generator = Generator_cgan(latent_dim=opt.latent_dim,
img_shape=img_shape,
n_classes=opt.n_classes)
discriminator = Discriminator_cgan(img_shape=img_shape,
n_classes=opt.n_classes)
elif opt.gan_type == 'acgan':
generator = Generator2(latent_dim=opt.latent_dim,
img_shape=img_shape,
n_classes=opt.n_classes)
discriminator = Discriminator2(img_shape=img_shape,
n_classes=opt.n_classes)
elif opt.arch == 'cnn':
generator = Generator1(latent_dim=opt.latent_dim)
discriminator = Discriminator1()
if cuda:
generator.cuda()
discriminator.cuda()
adversarial_loss.cuda()
auxiliary_loss.cuda()
# Configure data loader
transform = None
if opt.centering == 0 and opt.num_per == 1:
mean = [0.0052, -0.4731, 3.1408]
std = [0.4781, 0.4572, 0.5331]
elif opt.centering == 1 and opt.num_per == 1:
mean = [-0.0049, -0.2049, -0.0329]
opt.centering, opt.spherical,
opt.real_per, opt.num_per, 'train',
transform, opt.expt)
else:
traindata = NTURGBDData_full(0, None, 0, 'hcn', 'sub', 0, 0, 0,
opt.real_per, opt.num_per, 'train',
opt.expt)
dataloader = DataLoader(traindata,
batch_size=opt.batch_size,
shuffle=True,
num_workers=opt.n_cpu,
pin_memory=True)
# networks init
Generator1 = Generator1(input_dim=opt.latent_dim,
output_dim=opt.n_channels,
input_size=opt.img_width,
class_num=opt.n_classes)
Discriminator1 = Discriminator1(input_dim=opt.n_channels,
output_dim=1,
input_size=opt.img_width,
class_num=opt.n_classes)
Generator1_optimizer = optim.Adam(Generator1.parameters(),
lr=args.lrG,
betas=(args.beta1, args.beta2))
Discriminator1_optimizer = optim.Adam(Discriminator1.parameters(),
lr=args.lrD,
betas=(args.beta1, args.beta2))
if cuda:
Generator1.cuda()
Discriminator1.cuda()