def main(config):
# For fast training.
cudnn.benchmark = True
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# running preparation
prepareDirs(config)
writer = SummaryWriter(config.log_dir)
# Data preparation
data_loader = getProperLoader(config)
# Model Initialization
G = Generator(config.g_conv_dim, config.c_dim, config.g_repeat_num)
D = Discriminator(config.image_size, config.d_conv_dim, config.c_dim,
config.d_repeat_num)
g_optimizer = torch.optim.Adam(G.parameters(), config.g_lr,
[config.beta1, config.beta2])
d_optimizer = torch.optim.Adam(D.parameters(), config.d_lr,
[config.beta1, config.beta2])
G.to(device)
D.to(device)
# Training/Test
if config.mode == 'train':
train(config, G, D, g_optimizer, d_optimizer, data_loader, device,
writer)
elif config.mode == 'test':
test(config, G, data_loader, device)
netD.load_state_dict(netD.state_dict())
opt.start_training_step, opt.start_epoch = which_trainingstep_epoch(
opt.resume)
else:
model = Net()
netD = Discriminator()
mkdir_steptraing()
# model = torch.load('models/1/GFN_epoch_1.pkl')
# model.load_state_dict(model.state_dict())
# netD = torch.load('models/1/GFN_D_epoch_1.pkl')
# netD.load_state_dict(netD.state_dict())
model = model.to(device)
netD = netD.to(device)
criterion = torch.nn.MSELoss(size_average=True)
criterion = criterion.to(device)
cri_perception = VGGFeatureExtractor().to(device)
cri_gan = GANLoss('vanilla', 1.0, 0.0).to(device)
# textual init
vgg19 = cri_perception.vggNet
loss_layer = [1, 6, 11, 20]
loss_fns = [GramMSELoss()] * len(loss_layer)
if torch.cuda.is_available():
loss_fns = [loss_fn.cuda() for loss_fn in loss_fns]
style_weights = [1e3 / n**2 for n in [64, 128, 256, 512]]
optimizer = torch.optim.RMSprop(
filter(lambda p: p.requires_grad, model.parameters()), 0.0001)
