def init_models(self):
self.G_X = Generator(3, 3, nn.InstanceNorm2d)
self.D_X = Discriminator(3)
self.G_Y = Generator(3, 3, nn.InstanceNorm2d)
self.D_Y = Discriminator(3)
if self.load_models:
self.G_X.load_state_dict(
torch.load(self.output_path + "models/G_X",
map_location='cpu'))
self.G_Y.load_state_dict(
torch.load(self.output_path + "models/G_Y",
map_location='cpu'))
self.D_X.load_state_dict(
torch.load(self.output_path + "models/D_X",
map_location='cpu'))
self.D_Y.load_state_dict(
torch.load(self.output_path + "models/D_Y",
map_location='cpu'))
else:
self.G_X.apply(init_func)
self.G_Y.apply(init_func)
self.D_X.apply(init_func)
self.D_Y.apply(init_func)
self.G_X.to(self.device)
self.G_Y.to(self.device)
self.D_X.to(self.device)
self.D_Y.to(self.device)
def index(year, month, day):
gen1 = Generator.get_by_id(1)
gen2 = Generator.get_by_id(2)
gen3 = Generator.get_by_id(3)
date = dt.datetime(year, month, day).strftime('%Y-%m-%d')
if len(gen1.daily_record(year, month, day)) > 0:
data = {
"date":
date,
"gen_record": [
{
"name":
gen1.name,
"power": [
value.kWH
for value in gen1.daily_record(year, month, day)
]
},
{
"name":
gen2.name,
"power": [
value.kWH
for value in gen2.daily_record(year, month, day)
]
},
{
"name":
gen3.name,
"power": [
value.kWH
for value in gen3.daily_record(year, month, day)
]
},
]
}
else:
data = {
"date":
date,
"gen_record": [
{
"name": gen1.name,
"power": [randint(50, 100) for i in range(0, 25)]
},
{
"name": gen2.name,
"power": [randint(50, 100) for i in range(0, 25)]
},
{
"name": gen3.name,
"power": [randint(50, 100) for i in range(0, 25)]
},
]
}
#write code here to produce
return jsonify(data)
def addData():
if Generator.get_or_none(Generator.id == 1) == None:
gen1 = Generator(name='Generator 1')
gen1.save()
gen2 = Generator(name='Generator 2')
gen2.save()
gen3 = Generator(name='Generator 3')
gen3.save()
def build_model(args):
args.to_train = 'CDG'
networks = {}
opts = {}
if 'C' in args.to_train:
networks['C'] = GuidingNet(args.img_size, {'cont': args.sty_dim, 'disc': args.output_k})
networks['C_EMA'] = GuidingNet(args.img_size, {'cont': args.sty_dim, 'disc': args.output_k})
if 'D' in args.to_train:
networks['D'] = Discriminator(args.img_size, num_domains=args.output_k)
if 'G' in args.to_train:
networks['G'] = Generator(args.img_size, args.sty_dim, use_sn=False)
networks['G_EMA'] = Generator(args.img_size, args.sty_dim, use_sn=False)
if args.distributed:
if args.gpu is not None:
print('Distributed to', args.gpu)
torch.cuda.set_device(args.gpu)
args.batch_size = int(args.batch_size / args.ngpus_per_node)
args.workers = int(args.workers / args.ngpus_per_node)
for name, net in networks.items():
if name in ['inceptionNet']:
continue
net_tmp = net.cuda(args.gpu)
networks[name] = torch.nn.parallel.DistributedDataParallel(net_tmp, device_ids=[args.gpu], output_device=args.gpu)
else:
for name, net in networks.items():
net_tmp = net.cuda()
networks[name] = torch.nn.parallel.DistributedDataParallel(net_tmp)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
for name, net in networks.items():
networks[name] = net.cuda(args.gpu)
else:
for name, net in networks.items():
networks[name] = torch.nn.DataParallel(net).cuda()
if 'C' in args.to_train:
opts['C'] = torch.optim.Adam(
networks['C'].module.parameters() if args.distributed else networks['C'].parameters(),
1e-4, weight_decay=0.001)
if args.distributed:
networks['C_EMA'].module.load_state_dict(networks['C'].module.state_dict())
else:
networks['C_EMA'].load_state_dict(networks['C'].state_dict())
if 'D' in args.to_train:
opts['D'] = torch.optim.RMSprop(
networks['D'].module.parameters() if args.distributed else networks['D'].parameters(),
1e-4, weight_decay=0.0001)
if 'G' in args.to_train:
opts['G'] = torch.optim.RMSprop(
networks['G'].module.parameters() if args.distributed else networks['G'].parameters(),
1e-4, weight_decay=0.0001)
return networks, opts
def create_model(args):
generator = Generator(args.local_condition_dim, args.z_dim)
#discriminator = Multiple_Random_Window_Discriminators(args.local_condition_dim)
discriminator = Discriminator()
return generator, discriminator
def power_generated(year, month, day):
generators = Generator.select().order_by(Generator.created_at.asc())
date_select = dt.datetime(year, month, day, 0, 0, 0).strftime('%Y-%m-%d')
#create a seven day list from the selection date input
seven_day = [
dt.datetime(year, month, day) - timedelta(days=i) for i in range(7)
]
data = []
for gen in generators:
data_list = []
for i in reversed(range(7)):
data_list.append(
dict({
'date':
seven_day[i].date().strftime('%Y-%m-%d'),
'power':
gen.power_generated(seven_day[i].date().year,
seven_day[i].date().month,
seven_day[i].date().day),
}))
data.append(
dict({
'generator_id': gen.id,
'generator_name': gen.name,
'power_generated': data_list,
}))
return jsonify(data)
def main():
d = 'cuda' if torch.cuda.is_available() else 'cpu'
G_TYPE = 'LSTM'
DATA_FILEPATH ="../data/processed/logp_data.csv"
INPUT = 'smiles'
MINIBATCH = 128
training_data, testing_data, NUM_CHARS, MAX_LEN, W, T = load_generator_data(csv_file=DATA_FILEPATH,
input=INPUT,
minibatch_size=MINIBATCH,
device=d,
train_percentage=.95)
vocab = {v:k for k,v in T.word_index.items()}
if G_TYPE == 'LSTM':
G = LSTMGenerator(vocabulary=vocab, vocab_size=NUM_CHARS, embedding_dim=32).to(d)
else:
G = Generator(vocabulary=vocab, vocab_size=NUM_CHARS, embedding_dim=32, max_len=MAX_LEN).to(d)
train(model=G,
train_loader=training_data,
device=d,
tqdm=tqdm.tqdm,
max_len=MAX_LEN,
class_weights=W,
tokenizer=T,
iter_max=1000000,
iter_save=100000,
loss_save=1000,
save_name="LSTM_E32_H512")
def __init__(self, args, text_data):
super(ModelGumbel, self).__init__()
self.args = args
self.text_data = text_data
# embedding layer
if self.args.pre_embedding and not self.args.elmo:
# pre_trained embeddings are 300 dimensional, trainable
self.embedding_layer = nn.Embedding.from_pretrained(torch.Tensor(
self.text_data.pre_trained_embedding),
freeze=False)
elif self.args.elmo:
self.embedding_layer = Elmo(options_file,
weight_file,
1,
dropout=1.0 - self.args.drop_out,
requires_grad=self.args.train_elmo)
else:
self.embedding_layer = nn.Embedding(
num_embeddings=self.text_data.getVocabularySize(),
embedding_dim=self.args.embedding_size)
# first generator
self.generator = Generator(args=self.args)
# then encoder
self.encoder = Encoder(args=self.args)
def main(model_filename, pitch_model_filename, output_dir, batch_size):
model = torch.nn.Module()
model.add_module('encoder', Encoder(**encoder_config))
model.add_module('generator',
Generator(sum(encoder_config['n_out_channels'])))
model = load_checkpoint(model_filename, model).cuda()
model.eval()
if os.path.isfile(pitch_model_filename):
global pitch_model, use_predicted_pitch
use_predicted_pitch = True
pitch_model = PitchModel(**pitch_config)
pitch_model = load_checkpoint(pitch_model_filename, pitch_model).cuda()
pitch_model.eval()
testset = TestSet(**(data_config))
cond, name = testset[0]
for files in chunker(testset, batch_size):
files = list(zip(*files))
cond_input, file_paths = files[:-1], files[-1]
cond_input = [
utils.to_gpu(torch.from_numpy(np.stack(x))).float()
for x in cond_input
]
#cond_input = model.encoder(cond_input.transpose(1, 2)).transpose(1, 2)
cond_input = model.encoder(cond_input[0])
audio = model.generator(cond_input)
for i, file_path in enumerate(file_paths):
print("writing {}".format(file_path))
wav = audio[i].cpu().squeeze().detach().numpy() * 32768.0
write("{}/{}.wav".format(output_dir, file_path),
data_config['sampling_rate'], wav.astype(np.int16))
def _build_network(self):
cfg = self.cfg
if cfg.enc_type == 'cnn':
Encoder = EncoderCNN
elif cfg.enc_type == 'rnn':
Encoder = EncoderRNN
else:
raise ValueError('Unknown encoder type!')
if cfg.dec_type == 'cnn':
Decoder = DecoderCNN
elif cfg.dec_type == 'rnn':
Decoder = DecoderRNN
else:
raise ValueError('Unknown decoder type!')
# NOTE remove later!
self.embed_w = Embedding(cfg, self.vocab_w) # Word embedding
self.enc = Encoder(cfg) # Encoder
#self.reg = CodeSmoothingRegularizer(cfg) # Code regularizer
self.reg = VariationalRegularizer(cfg)
self.dec = Decoder(cfg, self.embed_w) # Decoder
self.dec2 = Decoder(cfg, self.embed_w) # Decoder
self.gen = Generator(cfg) # Generator
self.rev = ReversedGenerator(cfg)
self.disc = CodeDiscriminator(cfg, cfg.hidden_size_w) # Discriminator
#self.disc_s = SampleDiscriminator(cfg, cfg.hidden_size_w*2)
self._print_modules_info()
if cfg.cuda:
self._upload_modules_to_gpu()
def build_model_and_trainer(config, data_loader):
if config.model.type == 'classifier':
model_builder = Classifier(config)
model, parallel_model = WithLoadWeights(model_builder, model_name='classifier') \
.build_model(model_name='classifier')
trainer = ClassifierTrainer(model, parallel_model, data_loader, config)
return model, trainer
elif config.model.type == 'dcgan':
g_model_builder = Generator(config)
d_model_builder = Discriminator(config)
# c_model_builder = Classifier(config)
g = g_model_builder.define_model('generator')
d, parallel_d = d_model_builder.build_model('discriminator')
# c, _ = c_model_builder.build_model('classifier')
# Load weights to classifier
# checkpoint_path = './experiments/classifier_mnist/checkpoints/0050-classifier.hdf5'
# if os.path.exists(checkpoint_path):
# c.load_weights(checkpoint_path)
combined_model_builder = GANCombined(config)
combined, parallel_combined = WithLoadWeights(combined_model_builder, model_name='combined') \
.build_model(g=g, d=d, model_name='combined')
# .build_model(g=g, d=d, c=c, model_name='combined')
# trainer = GANTrainer(data_loader, config, g, d, parallel_d, c, combined, parallel_combined)
trainer = GANTrainer(data_loader, config, g, d, parallel_d, combined,
parallel_combined)
return combined, trainer
def get_base(args, input_dims, device):
if args.generator == 'convolutional':
net = Generator(nz=args.Z_dim, nn_type=args.g_model).to(device)
elif args.generator == 'gaussian':
net = energy_model.GaussianGenerator([input_dims]).to(device)
elif args.generator == 'made':
net = energy_model.MADEGenerator([input_dims],
mode='generator').to(device)
elif args.generator == 'nvp':
net = energy_model.NVP([input_dims],
device,
args.num_blocks,
mode='generator',
with_bn=args.gen_bn).to(device)
elif args.generator == 'maf':
net = energy_model.FlowGenerator([input_dims],
device,
args.num_blocks,
'maf',
mode='generator',
with_bn=args.gen_bn).to(device)
elif args.generator == 'mogmaf':
net = energy_model.FlowGenerator([input_dims],
device,
args.num_blocks,
'mogmaf',
mode='generator',
with_bn=args.gen_bn).to(device)
elif args.generator == 'toy':
net = tm.Generator(3)
return net
def __init__(self, train_loader, test_loader, valid_loader, general_args,
trainer_args):
super(GeneratorTrainer, self).__init__(train_loader, test_loader,
valid_loader, general_args)
# Paths
self.loadpath = trainer_args.loadpath
self.savepath = trainer_args.savepath
# Model
self.generator = Generator(general_args).to(self.device)
# Optimizer and scheduler
self.optimizer = torch.optim.Adam(params=self.generator.parameters(),
lr=trainer_args.lr)
self.scheduler = lr_scheduler.StepLR(
optimizer=self.optimizer,
step_size=trainer_args.scheduler_step,
gamma=trainer_args.scheduler_gamma)
# Load saved states
if os.path.exists(trainer_args.loadpath):
self.load()
# Loss function
self.time_criterion = nn.MSELoss()
self.use_freq_criterion = trainer_args.use_freq_criterion
self.lambda_freq = trainer_args.lambda_freq
self.frequency_criterion = nn.MSELoss()
def make_model(args, dataset):
N = args.gpu_num
class Model(): pass
model = Model()
netG = Generator(args)
netD = Discriminator(args)
netRNN = DS_SJE(args, dataset.embed_mat)
if N == 0:
setattr(model, "netG_0", netG)
setattr(model, "netD_0", netD)
setattr(model, "netRNN_0", netRNN)
else:
for i in range(N):
temp_netG = netG.copy()
temp_netD = netD.copy()
temp_netRNN = netRNN.copy()
temp_netG.gpu_id = i
temp_netD.gpu_id = i
temp_netRNN.gpu_id = i
setattr(model, f"netG_{i}", temp_netG.to_gpu(i))
setattr(model, f"netD_{i}", temp_netD.to_gpu(i))
setattr(model, f"netRNN_{i}", temp_netRNN.to_gpu(i))
return model
def __init__(self, batch_size, img_height, img_width, num_channels,
warm_up_generator, config: main_config.MainConfig,
output_paths: constants.OutputPaths):
super(GMCNNGan,
self).__init__(img_height, img_width, num_channels, batch_size,
config.training.wgan_training_ratio, output_paths)
self.img_height = img_height
self.img_width = img_width
self.num_channels = num_channels
self.warm_up_generator = warm_up_generator
self.learning_rate = config.training.learning_rate
self.num_gaussian_steps = config.model.num_gaussian_steps
self.gradient_penalty_loss_weight = config.model.gradient_penalty_loss_weight
self.id_mrf_loss_weight = config.model.id_mrf_loss_weight
self.adversarial_loss_weight = config.model.adversarial_loss_weight
self.nn_stretch_sigma = config.model.nn_stretch_sigma
self.vgg_16_layers = config.model.vgg_16_layers
self.id_mrf_style_weight = config.model.id_mrf_style_weight
self.id_mrf_content_weight = config.model.id_mrf_content_weight
self.gaussian_kernel_size = config.model.gaussian_kernel_size
self.gaussian_kernel_std = config.model.gaussian_kernel_std
self.add_mask_as_generator_input = config.model.add_mask_as_generator_input
self.generator_optimizer = Adam(lr=self.learning_rate,
beta_1=0.5,
beta_2=0.9)
self.discriminator_optimizer = Adam(lr=self.learning_rate,
beta_1=0.5,
beta_2=0.9)
self.local_discriminator_raw = LocalDiscriminator(
self.img_height, self.img_width, self.num_channels, output_paths)
self.global_discriminator_raw = GlobalDiscriminator(
self.img_height, self.img_width, self.num_channels, output_paths)
self.generator_raw = Generator(self.img_height, self.img_width,
self.num_channels,
self.add_mask_as_generator_input,
output_paths)
# define generator model
self.global_discriminator_raw.disable()
self.local_discriminator_raw.disable()
self.generator_model = self.define_generator_model(
self.generator_raw, self.local_discriminator_raw,
self.global_discriminator_raw)
# define global discriminator model
self.global_discriminator_raw.enable()
self.generator_raw.disable()
self.global_discriminator_model = self.define_global_discriminator(
self.generator_raw, self.global_discriminator_raw)
# define local discriminator model
self.local_discriminator_raw.enable()
self.global_discriminator_raw.disable()
self.local_discriminator_model = self.define_local_discriminator(
self.generator_raw, self.local_discriminator_raw)
def __init__(self,
num_fakes=16,
rand_dim=128,
size=(32, 32),
use_gpu=False):
super(GAN, self).__init__()
self.generator = Generator(num_fakes, rand_dim, size, use_gpu)
self.discriminator = Discriminator((1, ) + size)
def main():
input_dir, output_dir = sys.argv[1:]
print('Pytorch version:', torch.__version__)
data_val = np.load(input_dir + '/data_val.npz', allow_pickle=True)
val_data_path_out = output_dir + '/data_val_prediction.npz'
data_test = np.load(input_dir + '/data_test.npz', allow_pickle=True)
test_data_path_out = output_dir + '/data_test_prediction.npz'
generator_cpu = Generator(NOISE_DIM)
generator_cpu.load_state_dict(torch.load(os.path.dirname(os.path.abspath(__file__)) + '/generator.pt'))
generator_cpu.eval()
# val
ParticleMomentum_val = torch.tensor(data_val['ParticleMomentum']).float()
ParticlePoint_val = torch.tensor(data_val['ParticlePoint'][:, :2]).float()
ParticleMomentum_ParticlePoint_val = torch.cat([ParticleMomentum_val, ParticlePoint_val], dim=1)
calo_dataset_val = utils.TensorDataset(ParticleMomentum_ParticlePoint_val)
calo_dataloader_val = torch.utils.data.DataLoader(calo_dataset_val, batch_size=BATCH_SIZE, shuffle=False)
with torch.no_grad():
EnergyDeposit_val = []
for ParticleMomentum_ParticlePoint_val_batch in tqdm(calo_dataloader_val):
noise = torch.randn(len(ParticleMomentum_ParticlePoint_val_batch[0]), NOISE_DIM)
EnergyDeposit_val_batch = generator_cpu(noise, ParticleMomentum_ParticlePoint_val_batch[0]).detach().numpy()
EnergyDeposit_val.append(EnergyDeposit_val_batch)
np.savez_compressed(val_data_path_out,
EnergyDeposit=np.concatenate(EnergyDeposit_val, axis=0).reshape(-1, 30, 30))
del EnergyDeposit_val
del data_val; del ParticleMomentum_val; del ParticlePoint_val; del ParticleMomentum_ParticlePoint_val;
del calo_dataset_val; calo_dataloader_val
ParticleMomentum_test = torch.tensor(data_test['ParticleMomentum']).float()
ParticlePoint_test = torch.tensor(data_test['ParticlePoint'][:, :2]).float()
ParticleMomentum_ParticlePoint_test = torch.cat([ParticleMomentum_test, ParticlePoint_test], dim=1)
calo_dataset_test = utils.TensorDataset(ParticleMomentum_ParticlePoint_test)
calo_dataloader_test = torch.utils.data.DataLoader(calo_dataset_test, batch_size=BATCH_SIZE, shuffle=False)
with torch.no_grad():
EnergyDeposit_test = []
for ParticleMomentum_ParticlePoint_test_batch in tqdm(calo_dataloader_test):
noise = torch.randn(len(ParticleMomentum_ParticlePoint_test_batch[0]), NOISE_DIM)
EnergyDeposit_test_batch = generator_cpu(noise, ParticleMomentum_ParticlePoint_test_batch[0]).detach().numpy()
EnergyDeposit_test.append(EnergyDeposit_test_batch)
np.savez_compressed(test_data_path_out,
EnergyDeposit=np.concatenate(EnergyDeposit_test, axis=0).reshape(-1, 30, 30))
del EnergyDeposit_test
del data_test; del ParticleMomentum_test; del ParticlePoint_test; del ParticleMomentum_ParticlePoint_test;
del calo_dataset_test; calo_dataloader_test
return 0
def main(game_name, game_length):
#Game description
reward_mode = 'base'
reward_scale = 1.0
elite_prob = 0
env = Env(
game_name, game_length, {
'reward_mode': reward_mode,
'reward_scale': reward_scale,
'elite_prob': elite_prob
})
#Network
latent_shape = (512, )
dropout = 0
lr = .0001
gen = Generator(latent_shape, env, 'nearest', dropout, lr)
#Agent
num_processes = 1
experiment = "Experiments"
lr = .00025
model = 'base'
dropout = .3
reconstruct = None
r_weight = .05
Agent.num_steps = 5
Agent.entropy_coef = .01
Agent.value_loss_coef = .1
agent = Agent(env, num_processes, experiment, 0, lr, model, dropout,
reconstruct, r_weight)
#Training
gen_updates = 1e4
gen_batch = 32
gen_batches = 1
diversity_batches = 0
rl_batch = 1e4
pretrain = 0
elite_persist = False
elite_mode = 'mean'
load_version = 0
notes = ''
agent.writer.add_hparams(
{
'Experiment': experiment,
'RL_LR': lr,
'Minibatch': gen_batch,
'RL_Steps': rl_batch,
'Notes': notes
}, {})
t = Trainer(gen, agent, experiment, load_version, elite_mode,
elite_persist)
t.loss = lambda x, y: x.mean().pow(2)
t.train(gen_updates, gen_batch, gen_batches, diversity_batches, rl_batch,
pretrain)
def main(game_name, game_length):
#Game description
reward_mode = 'time'
reward_scale = 1.0
elite_prob = .5
env = Env(
game_name, game_length, {
'reward_mode': reward_mode,
'reward_scale': reward_scale,
'elite_prob': elite_prob
})
#Network
latent_shape = (512, )
dropout = .2
lr = .0001
gen = Generator(latent_shape, env, 'pixel', dropout, lr)
#Agent
num_processes = 16
experiment = "Experiment_Paper"
lr = .00025
model = 'resnet'
dropout = 0
reconstruct = gen
r_weight = .05
Agent.num_steps = 5
Agent.entropy_coef = .01
Agent.value_loss_coef = .1
agent = Agent(env, num_processes, experiment, 0, lr, model, dropout,
reconstruct, r_weight)
#Training
gen_updates = 100
gen_batch = 128
gen_batches = 10
diversity_batches = 90
rl_batch = 1e6
pretrain = 2e7
elite_persist = True
elite_mode = 'max'
load_version = 0
notes = 'Configured to match paper results'
agent.writer.add_hparams(
{
'Experiment': experiment,
'RL_LR': lr,
'Minibatch': gen_batch,
'RL_Steps': rl_batch,
'Notes': notes
}, {})
t = Trainer(gen, agent, experiment, load_version, elite_mode,
elite_persist)
t.train(gen_updates, gen_batch, gen_batches, diversity_batches, rl_batch,
pretrain)
def build_model(self):
self.G = Generator(self.noise_n, self.G_last_act)
self.D = BEGAN_Discriminator(self.noise_n // 2, self.D_last_act)
self.G_optimizer = torch.optim.Adam(self.G.parameters(), self.G_lr,
[self.beta1, self.beta2])
self.D_optimizer = torch.optim.Adam(self.D.parameters(), self.D_lr,
[self.beta1, self.beta2])
if torch.cuda.is_available():
self.G.cuda()
self.D.cuda()
def __init__(self, sent_len, vocab_size):
graph = tf.Graph()
with graph.as_default():
self.G = Generator(sent_len=sent_len,
vocab_size=vocab_size,
embedding_size=300,
init_embedding=None,
rnn_h_dim=150,
batch_size=50)
ckpt = CheckpointManager("model_50_" + str(sent_len))
self.sess = tf.Session(graph=graph)
ckpt.restore(self.sess)
def __init__(self, embeddings, args):
super(HardRationale3PlayerClassificationModel,
self).__init__(embeddings, args)
self.generator = Generator(args, self.input_dim)
self.highlight_percentage = args.highlight_percentage
self.highlight_count = args.highlight_count
self.exploration_rate = args.exploration_rate
self.loss_func = nn.CrossEntropyLoss(reduce=False)
if args.margin is not None:
self.margin = args.margin
def main(args):
# Load PC
pc = trimesh.load(args.pc)
pc_vox, scale, cent = pc2vox(pc.vertices, args.res)
pc_vox = np.reshape(pc_vox, (args.res,) * 3).astype('float32')
# save scale file
from utils.preprocess_scan import SCALE, new_cent
np.save(join(args.out_path, 'cent.npy'), [scale / SCALE, (cent - new_cent)])
# Load network
if args.model == 'IPNet':
net = model.IPNet(hidden_dim=args.decoder_hidden_dim, num_parts=14)
gen = GeneratorIPNet(net, 0.5, exp_name=None, resolution=args.retrieval_res,
batch_points=args.batch_points)
elif args.model == 'IPNetMano':
net = model.IPNetMano(hidden_dim=args.decoder_hidden_dim, num_parts=7)
gen = GeneratorIPNetMano(net, 0.5, exp_name=None, resolution=args.retrieval_res,
batch_points=args.batch_points)
elif args.model == 'IPNetSingleSurface':
net = model.IPNetSingleSurface(hidden_dim=args.decoder_hidden_dim, num_parts=14)
gen = Generator(net, 0.5, exp_name=None, resolution=args.retrieval_res,
batch_points=args.batch_points)
else:
print('Wow watch where u goin\' with that model')
exit()
# Load weights
print('Loading weights from,', args.weights)
checkpoint_ = torch.load(args.weights)
net.load_state_dict(checkpoint_['model_state_dict'])
# Run IPNet and Save
if not os.path.exists(args.out_path):
os.makedirs(args.out_path)
data = {'inputs': torch.tensor(pc_vox[np.newaxis])} # add a batch dimension
if args.model == 'IPNet':
full, body, parts = gen.generate_meshs_all_parts(data)
body.set_vertex_colors_from_weights(parts)
body.write_ply(args.out_path + '/body.ply')
body.write_obj(args.out_path + '/body_nosmpl.obj')
np.save(args.out_path + '/parts.npy', parts)
elif args.model == 'IPNetMano':
full, parts = gen.generate_meshs_all_parts(data)
np.save(args.out_path + '/parts.npy', parts)
elif args.model == 'IPNetSingleSurface':
full = gen.generate_mesh_all(data)
full.write_ply(args.out_path + '/full.ply')
full.write_obj(args.out_path + '/full_nosmpl.obj')
def pretrain(img_data_loader, num_epochs=100, decay_factor=0.1, initial_lr=0.0001, checkpoint=None, save=True):
if checkpoint is not None:
imported_checkpoint = torch.load(checkpoint)
generator = imported_checkpoint['generator']
starting_epoch = imported_checkpoint['epoch'] + 1
generator_optimizer = imported_checkpoint['generator_optimizer']
else:
generator = Generator()
generator_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, generator.parameters()), lr=initial_lr)
starting_epoch = 0
pretrain_criterion = F.mse_loss
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Push generator to gpu if it's available
generator.to(device)
generator.train()
for epoch in range(starting_epoch, num_epochs):
# If we're halfway through, reduce learning rate
if epoch == num_epochs//2:
for group in generator_optimizer.param_groups:
group['lr'] = group['lr']*decay_factor
running_loss = 0.0
# Iterate through the dataloader
for ii, (hr_imgs, lr_imgs) in enumerate(tqdm(img_data_loader)):
hr_imgs, lr_imgs = hr_imgs.to(device), lr_imgs.to(device)
# Super-resolve low-resolution images
sr_imgs = generator(lr_imgs)
# Compute loss, backpropagate, and update generator
loss = pretrain_criterion(sr_imgs, hr_imgs)
generator_optimizer.zero_grad()
loss.backward()
generator_optimizer.step()
# Increment running loss
running_loss += loss.item()
del hr_imgs, lr_imgs, sr_imgs
print("Pretraining epoch {}, Average loss: {}".format(epoch, running_loss/len(img_data_loader)))
if save:
# Save the final pretrained model if you're going to continue later
torch.save({'epoch': epoch,
'generator': generator,
'generator_optimizer': generator_optimizer},
'pretrained_celebahq_generator.pth.tar')
del generator
def main():
data_loader = DataLoader(data_path, batch_size)
generator = Generator(vocab_size, g_emb_dim, g_hidden_dim)
discriminator = Discriminator(vocab_size, d_hidden_dim)
gen_optimizer = optim.Adam(generator.parameters(), lr=0.0001)
disc_optimizer = optim.Adam(discriminator.parameters(), lr=0.0001)
bce_criterion = nn.BCELoss()
gen_criterion = nn.NLLLoss(size_average=False)
if (opt.cuda):
generator.cuda()
pretrain_lstm(generator, data_loader, gen_optimizer, gen_criterion, 10)
all_G_losses = []
all_D_losses = []
for i in tqdm(range(total_epochs)):
g_losses, d_losses = train_gan_epoch(discriminator, generator,
data_loader, gen_optimizer,
disc_optimizer, bce_criterion)
all_G_losses += g_losses
all_D_losses += d_losses
sample = generator.sample(batch_size, g_seq_length)
print(generator)
with open('./data/gumbel_softmax_gan_gen.txt', 'w') as f:
for each_str in data_loader.convert_to_char(sample):
f.write(each_str + '\n')
gen_file_name = 'gen_gumbel_softmax_' + str(total_epochs) + '.pth'
disc_file_name = 'disc_gumbel_softmax_' + str(total_epochs) + '.pth'
Utils.save_checkpoints(checkpoint_dir, gen_file_name, generator)
Utils.save_checkpoints(checkpoint_dir, disc_file_name, discriminator)
plt.plot(list(range(len(all_G_losses))),
all_G_losses,
'g-',
label='gen loss')
plt.plot(list(range(len(all_D_losses))),
all_D_losses,
'b-',
label='disc loss')
plt.legend()
plt.show()
def get_modules(opt):
modules = {}
disc = Discriminator()
gen = Generator()
clf = Classifier()
if opt.cuda:
disc = disc.cuda()
gen = gen.cuda()
clf = clf.cuda()
modules['Discriminator'] = disc
modules['Generator'] = gen
modules['Classifier'] = clf
return modules
def __init__(self, opt, training, device):
"""
:param opt: options for creating the generator and discriminator
"""
super(Pix2Pix, self).__init__()
self.opt = opt
self.training = training
self.device = device
if self.training:
self.netG = Generator(self.opt.netG_in, self.opt.netG_out)
self.netG.init_weight()
self.netG.to(self.device)
if self.opt.netD_name == 'PixelGAN':
self.netD = PixelGAN(self.opt.netD_in, self.opt.netD_out)
elif opt.netD_name == 'PatchGAN':
self.netD = PatchGAN(self.opt.netD_in, self.opt.netD_out,
self.opt.netD_layers)
self.netD.init_weight()
self.netD.to(self.device)
else:
self.netG = Generator(self.opt.netG_in, self.opt.netG_out)
self.netG.init_weight()
self.netG.to(self.device)
if self.training:
self.lossGAN = BCEWithLogitsLoss().to(self.device)
self.lossL1 = L1Loss().to(self.device)
self.optimizer_G = Adam(self.netG.parameters(),
lr=opt.lr,
betas=(self.opt.beta1, self.opt.beta2))
self.optimizer_D = Adam(self.netD.parameters(),
lr=opt.lr,
betas=(self.opt.beta1, self.opt.beta2))
def get_generator(loadpath, device, general_args):
"""
Returns a pre-trained generator in evaluation mode.
:param loadpath: location of the generator trainer (string).
:param device: either 'cpu' or 'cuda' depending on hardware availability (string).
:param general_args: argument parser that contains the arguments that are independent to the script being executed.
:return: pre-trained generator (nn.Module).
"""
# Instantiate a new generator with identical architecture
generator = Generator(general_args=general_args).to(device)
# Restore pre-trained weights
checkpoint = torch.load(loadpath, map_location=device)
generator.load_state_dict(checkpoint['generator_state_dict'])
return generator.eval()
def build_model(args):
generator = Generator(args)
discriminator = Discriminator(args)
mapping_network = MappingNetwork(args)
generator_ema = copy.deepcopy(generator)
mapping_network_ema = copy.deepcopy(mapping_network)
nets = Munch(generator=generator,
discriminator=discriminator,
mapping_network=mapping_network)
nets_ema = Munch(generator=generator_ema,
mapping_network=mapping_network_ema)
return nets, nets_ema
def __init__(self, config, debug=False):
super(AdaInGEN, self).__init__()
self.config = config
self.color_dim = config.color_dim
self.image_size = config.image_size
self.style_dim = config.style_dim
self.c_dim = config.c_dim
self.generator = Generator(config, debug=False)
in_dim = self.style_dim + self.c_dim
de_params = self.get_num_de_params(self.generator)
self.Domain_Embedding = DE(
config, in_dim, de_params, train=False, debug=debug)
if debug:
self.debug()