def get_system(name, args, schema=None, timed=False, model_path=None):
from core.price_tracker import PriceTracker
lexicon = PriceTracker(args.price_tracker_model)
if name == 'rulebased':
from rulebased_system import RulebasedSystem
from model.generator import Templates, Generator
from model.manager import Manager
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
elif name == 'hybrid':
from hybrid_system import HybridSystem
templates = Templates.from_pickle(args.templates)
manager = PytorchNeuralSystem(args, schema, lexicon, model_path, timed)
generator = Generator(templates)
return HybridSystem(lexicon, generator, manager, timed)
elif name == 'cmd':
from cmd_system import CmdSystem
return CmdSystem()
elif name == 'pt-neural':
from neural_system import PytorchNeuralSystem
assert model_path
return PytorchNeuralSystem(args, schema, lexicon, model_path, timed)
else:
raise ValueError('Unknown system %s' % name)
def get_generators(self, len_val, src_vocab, text_embedding, args):
gate_gen = None
if args['slot_gating']:
gate_gen = Generator(len(GATES), scope_name="gate")
fertility_generator = Generator(len_val + 1, scope_name="fertility")
state_generator = Generator(src_vocab,
text_embedding.get_embedding_wieght(),
scope_name='state')
point_state_generator = PointerGenerator(
state_generator=state_generator, scope_name='point_generator')
return fertility_generator, point_state_generator, gate_gen
def load_generators(self):
"""Load the generator dictionary."""
self.generators = {}
try:
df = pd.read_csv(GENERATORS_PATH, index_col=0, keep_default_na=False)
for index, row in df.iterrows():
weight_map = {name: value for name, value in zip(df.columns, row)}
generator_name = weight_map.pop('generator_name')
generator = Generator(weight_map)
self.generators[generator_name] = generator
except Exception as e:
print(f"Unable to load file '{GENERATORS_PATH}', aborting: {e}")
self.generators = {
"Custom": Generator()
}
def get_system(name, args, schema=None, timed=False, model_path=None):
lexicon = PriceTracker(args.price_tracker_model)
if name == 'rulebased':
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
#elif name == 'config-rulebased':
# configs = read_json(args.rulebased_configs)
# return ConfigurableRulebasedSystem(configs, lexicon, timed_session=timed, policy=args.config_search_policy, max_chats_per_config=args.chats_per_config, db=args.trials_db, templates=templates)
elif name == 'cmd':
return CmdSystem()
elif name.startswith('ranker'):
# TODO: hack
#retriever1 = Retriever(args.index+'-1', context_size=args.retriever_context_len, num_candidates=args.num_candidates)
#retriever2 = Retriever(args.index+'-2', context_size=args.retriever_context_len, num_candidates=args.num_candidates)
retriever = Retriever(args.index, context_size=args.retriever_context_len, num_candidates=args.num_candidates)
if name == 'ranker-ir':
return IRRankerSystem(schema, lexicon, retriever)
elif name == 'ranker-ir1':
return IRRankerSystem(schema, lexicon, retriever1)
elif name == 'ranker-ir2':
return IRRankerSystem(schema, lexicon, retriever2)
elif name == 'ranker-neural':
return NeuralRankerSystem(schema, lexicon, retriever, model_path, args.mappings)
else:
raise ValueError
elif name in ('neural-gen', 'neural-sel'):
assert model_path
return NeuralSystem(schema, lexicon, model_path, args.mappings, args.decoding, index=args.index, num_candidates=args.num_candidates, retriever_context_len=args.retriever_context_len, timed_session=timed)
else:
raise ValueError('Unknown system %s' % name)
def main(args):
checkpoint = torch.load(args.checkpoint_path)
if args.config is not None:
hp = HParam(args.config)
else:
hp = load_hparam_str(checkpoint['hp_str'])
model = Generator(hp.audio.n_mel_channels).cuda()
model.load_state_dict(checkpoint['model_g'])
model.eval(inference=False)
with torch.no_grad():
for melpath in tqdm.tqdm(
glob.glob(os.path.join(args.input_folder, '*.mel'))):
mel = torch.load(melpath)
if len(mel.shape) == 2:
mel = mel.unsqueeze(0)
mel = mel.cuda()
audio = model.inference(mel)
audio = audio.cpu().detach().numpy()
out_path = melpath.replace(
'.mel', '_reconstructed_epoch%04d.wav' % checkpoint['epoch'])
write(out_path, hp.audio.sampling_rate, audio)
def get_system(name, args, schema=None, timed=False, model_path=None):
if name in ('rulebased', 'neural'):
lexicon = Lexicon(schema,
args.learned_lex,
stop_words=args.stop_words,
lexicon_path=args.lexicon)
if args.inverse_lexicon:
realizer = InverseLexicon.from_file(args.inverse_lexicon)
else:
realizer = DefaultInverseLexicon()
if name == 'rulebased':
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
elif name == 'neural':
assert args.model_path
return NeuralSystem(schema,
lexicon,
args.model_path,
args.fact_check,
args.decoding,
realizer=realizer)
elif name == 'cmd':
return CmdSystem()
else:
raise ValueError('Unknown system %s' % name)
def load_generator(g_params=None, is_g_clone=False, ckpt_dir=None):
from model.generator import Generator
if g_params is None:
g_params = {
'z_dim': 512,
'w_dim': 512,
'labels_dim': 254,
'n_mapping': 8,
'resolutions': [4, 8, 16, 32, 64, 128, 256, 512, 1024],
'featuremaps': [512, 512, 512, 512, 512, 256, 128, 64, 32],
}
#test_latent = tf.ones((1, g_params['z_dim']), dtype=tf.float32)
test_labels = tf.ones((1, g_params['labels_dim']), dtype=tf.float32)
# build generator model
generator = Generator(g_params)
_ = generator(test_labels)
if ckpt_dir is not None:
if is_g_clone:
ckpt = tf.train.Checkpoint(g_clone=generator)
else:
ckpt = tf.train.Checkpoint(generator=generator)
manager = tf.train.CheckpointManager(ckpt, ckpt_dir, max_to_keep=1)
ckpt.restore(manager.latest_checkpoint).expect_partial()
if manager.latest_checkpoint:
print(f'Generator restored from {manager.latest_checkpoint}')
return generator
def main(args):
checkpoint = torch.load(args.checkpoint_path)
if args.config is not None:
hp = HParam(args.config)
else:
hp = load_hparam_str(checkpoint['hp_str'])
model = Generator(hp.audio.n_mel_channels).cuda()
model.load_state_dict(checkpoint['model_g'])
model.eval()
with torch.no_grad():
for melpath in tqdm.tqdm(glob.glob(os.path.join(args.input_folder, '*.mel'))):
mel = torch.load(melpath)
if len(mel.shape) == 2:
mel = mel.unsqueeze(0)
mel = mel.cuda()
# pad input mel with zeros to cut artifact
# see https://github.com/seungwonpark/melgan/issues/8
zero = torch.full((1, hp.audio.n_mel_channels, 10), -11.5129).cuda()
mel = torch.cat((mel, zero), axis=2)
audio = model(mel)
audio = audio.squeeze() # collapse all dimension except time axis
audio = audio[:-(hp.audio.hop_length*10)]
audio = MAX_WAV_VALUE * audio
audio = audio.clamp(min=-MAX_WAV_VALUE, max=MAX_WAV_VALUE)
audio = audio.short()
audio = audio.cpu().detach().numpy()
out_path = melpath.replace('.mel', '_reconstructed_epoch%04d.wav' % checkpoint['epoch'])
write(out_path, hp.audio.sampling_rate, audio)
def __init__(self,
width,
height,
ichan,
ochan,
l1_weight=100.,
lr=0.0002,
beta1=0.5):
# def __init__(self, width, height, ichan, ochan, l1_weight=1000., lr=0.0002, beta1=0.5): # I enlarge the l1_weight to see what will happen
"""
width: image width in pixel.
height: image height in pixel.
ichan: number of channels used by input images.
ochan: number of channels used by output images.
l1_weight: L1 loss weight.
lr: learning rate for ADAM optimizer.
beta1: beta1 parameter for ADAM optimizer.
"""
self._is_training = tf.placeholder(tf.bool)
self._g_inputs = tf.placeholder(tf.float32,
[None, width, height, ichan])
self._d_inputs_a = tf.placeholder(tf.float32,
[None, width, height, ichan])
self._d_inputs_b = tf.placeholder(tf.float32,
[None, width, height, ochan])
self._g = Generator(self._g_inputs, self._is_training, ochan)
self._real_d = Discriminator(
tf.concat([self._d_inputs_a, self._d_inputs_b], axis=3),
self._is_training)
self._fake_d = Discriminator(tf.concat(
[self._d_inputs_a, self._g._decoder['cl9']['fmap']], axis=3),
self._is_training,
reuse=True)
self._g_loss = -tf.reduce_mean(
tf.log(self._fake_d._discriminator['l5']['fmap'])
) + l1_weight * tf.reduce_mean(
tf.abs(self._d_inputs_b - self._g._decoder['cl9']['fmap']))
self._d_loss = -tf.reduce_mean(
tf.log(self._real_d._discriminator['l5']['fmap']) +
tf.log(1.0 - self._fake_d._discriminator['l5']['fmap']))
# self._g_loss = tf.reduce_mean(tf.square(self._d_inputs_b - self._g._decoder['cl9']['fmap'])) # set g_loss = mse loss !!!!!
# self._d_loss = -tf.reduce_mean(tf.log(self._real_d._discriminator['l5']['fmap']) + tf.log(1.0 - self._fake_d._discriminator['l5']['fmap']))
g_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='G')
with tf.control_dependencies(g_update_ops):
self._g_train_step = tf.train.AdamOptimizer(
lr, beta1=beta1).minimize(self._g_loss,
var_list=tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES,
scope='G'))
d_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope='D')
with tf.control_dependencies(d_update_ops):
self._d_train_step = tf.train.AdamOptimizer(
lr, beta1=beta1).minimize(self._d_loss,
var_list=tf.get_collection(
tf.GraphKeys.TRAINABLE_VARIABLES,
scope='D'))
def main():
if __name__ == '__main__':
writer = tensorboard.SummaryWriter(log_dir='./logs')
device = torch.device(
'cuda:0') if torch.cuda.is_available() else torch.device('cpu')
vggloss = VGGLosses(device=device).to(device)
dataset = Dataset(root='dataset/Shinkai',
style_transform=transform,
smooth_transform=transform)
dataloader = DataLoader(dataset, batch_size=16, shuffle=True)
G = Generator().to(device)
D = PatchDiscriminator().to(device)
G.apply(weights_init)
D.apply(weights_init)
optimizer_G = optim.Adam(G.parameters(), lr=0.0001) #Based on paper
optimizer_D = optim.Adam(D.parameters(), lr=0.0004) #Based on paper
init_train(20, lr=0.1, con_weight=1.0)
train(epoch=10, con_weight=1.2, gra_weight=2., col_weight=10.)
def transformer(args):
d_model = args.d_model
d_hidden = args.d_hidden
n_heads = args.n_heads
src_vocab = args.src_vocab
trg_vocab = args.trg_vocab
n_layers = args.n_layers
input_dp = args.input_drop_ratio
model_dp = args.drop_ratio
src_emb_pos = nn.Sequential(Embeddings(d_model, src_vocab), PositionalEncoding(d_model, input_dp))
enc_dp = args.enc_dp
dec_dp = args.dec_dp
encoder = GATEncoder(d_model, d_hidden, n_heads, enc_dp, args.n_enclayers)
tgt_emb_pos = nn.Sequential(Embeddings(d_model, trg_vocab), PositionalEncoding(d_model, input_dp))
decoder = Decoder(clone(DecoderLayer(d_model, n_heads, d_hidden, dec_dp), n_layers))
generator = Generator(d_model, trg_vocab)
model = EncoderDecoder(encoder, decoder, src_emb_pos, tgt_emb_pos, generator)
if args.share_vocab:
model.src_embed[0].lut.weight = model.tgt_embed[0].lut.weight
if args.share_embed:
model.generator.proj.weight = model.tgt_embed[0].lut.weight
return model
def test(config):
print(config)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
transform = transforms.Compose([
transforms.Resize((config.image_size, config.image_size)),
transforms.ToTensor(),
])
test_dataset = TestDataset(test_dir=config.test_dir, transforms=transform)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1)
generator = Generator(image_size=config.image_size).to(device)
if config.load_model:
generator.load_state_dict(torch.load(config.load_model))
if not exists(config.result_path):
os.makedirs(config.result_path)
generator.eval()
if not exists(config.result_path):
os.makedirs(config.result_path)
for i, data in enumerate(test_loader):
source = data['source'].to(device).float()
fake = generator(source)
plt.subplot(121)
plt.imshow(tensor2image(source))
plt.title('source')
plt.subplot(122)
plt.imshow(tensor2image(fake))
plt.title('fake')
plt.savefig(join(config.result_path, 'step-%d.png' % (i + 1)))
generator.train()
def make_model(src_vocab,
tgt_vocab,
N=6,
d_model=512,
d_ff=2048,
h=8,
dropout=0.1):
c = copy.deepcopy
attn = MultiHeadedAttention(h, d_model).to(args.device)
ff = PositionwiseFeedForward(d_model, d_ff, dropout).to(args.device)
position = PositionalEncoding(d_model, dropout).to(args.device)
model = Transformer(
Encoder(
EncoderLayer(d_model, c(attn), c(ff), dropout).to(args.device),
N).to(args.device),
Decoder(
DecoderLayer(d_model, c(attn), c(attn), c(ff),
dropout).to(args.device), N).to(args.device),
nn.Sequential(
Embeddings(d_model, src_vocab).to(args.device), c(position)),
nn.Sequential(
Embeddings(d_model, tgt_vocab).to(args.device), c(position)),
Generator(d_model, tgt_vocab)).to(args.device)
# This was important from their code.
# Initialize parameters with Glorot / fan_avg.
for p in model.parameters():
if p.dim() > 1:
nn.init.xavier_uniform_(p)
return model.to(args.device)
def main(args):
checkpoint = torch.load(args.checkpoint_path)
if args.config is not None:
hp = HParam(args.config)
else:
hp = load_hparam_str(checkpoint['hp_str'])
model = Generator(hp.audio.n_mel_channels).cuda()
model.load_state_dict(checkpoint['model_g'])
model.eval(inference=True)
with torch.no_grad():
mel = torch.from_numpy(np.load(args.input))
if len(mel.shape) == 2:
mel = mel.unsqueeze(0)
mel = mel.cuda()
audio = model.inference(mel)
# For multi-band inference
print(audio.shape)
audio = audio.squeeze(0) # collapse all dimension except time axis
if args.d:
denoiser = Denoiser(model).cuda()
audio = denoiser(audio, 0.1)
audio = audio.squeeze()
audio = audio[:-(hp.audio.hop_length * 10)]
audio = MAX_WAV_VALUE * audio
audio = audio.clamp(min=-MAX_WAV_VALUE, max=MAX_WAV_VALUE - 1)
audio = audio.short()
audio = audio.cpu().detach().numpy()
out_path = args.input.replace(
'.npy', '_hifi_GAN_epoch%04d.wav' % checkpoint['epoch'])
write(out_path, hp.audio.sampling_rate, audio)
def load_gan(self):
# Get the restored generator
self.G = Generator(0, 0, restore=True)
# Use generator's latent size
self.latent_size = self.G.z_length
# Get the restored discriminator
self.D = Discriminator(0, restore=True)
def __init__(self, **kwargs):
super(Prawler, self).__init__(**kwargs)
self.toolbox = None
self.field = Field()
self.generator = Generator(field=self.field)
self.relation_manager = RelationManager(field=self.field)
self.drag_manager = DragManager(field=self.field)
def prepare_models(config):
discriminator = Discriminator.create_model(
config["model"]["discriminator"])
ModelInitializator._init_model(discriminator, "discriminator", config)
generator = Generator.create_model(config["model"]["generator"])
ModelInitializator._init_model(generator, "generator", config)
gan = Gan.create_model(discriminator, generator, config)
ModelInitializator._init_model(gan, "gan", config)
return generator, discriminator, gan
def melgan(model_name='nvidia_tacotron2_LJ11_epoch3200', pretrained=True, progress=True):
params = model_params[model_name]
model = Generator(params['mel_channel'])
if pretrained:
state_dict = torch.hub.load_state_dict_from_url(params['model_url'],
progress=progress)
model.load_state_dict(state_dict['model_g'])
model.eval(inference=True)
return model
def restore(self):
print('Restoring model...')
generator = Generator(self.resolution, self.batch_size)
generator.restore()
discriminator = Discriminator(self.resolution)
discriminator.restore()
self.restored = True
self.initialize(generator, discriminator)
def get_system(name, args, schema, model_path=None, timed=False):
lexicon = Lexicon.from_pickle(args.lexicon)
templates = Templates.from_pickle(args.templates)
if name == 'rulebased':
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
elif name == 'cmd':
return CmdSystem()
else:
raise ValueError('Unknown system %s' % name)
def __init__(self, model_dir, g_optimizer, d_optimizer, lr, warmup,
max_iters):
super().__init__()
self.model_dir = model_dir
if not os.path.exists(f'checkpoints/{model_dir}'):
os.makedirs(f'checkpoints/{model_dir}')
self.logs_dir = f'checkpoints/{model_dir}/logs'
if not os.path.exists(self.logs_dir):
os.makedirs(self.logs_dir)
self.writer = SummaryWriter(self.logs_dir)
self.arcface = ArcFaceNet(50, 0.6, 'ir_se').cuda()
self.arcface.eval()
self.arcface.load_state_dict(torch.load(
'checkpoints/model_ir_se50.pth', map_location='cuda'),
strict=False)
self.mobiface = MobileFaceNet(512).cuda()
self.mobiface.eval()
self.mobiface.load_state_dict(torch.load(
'checkpoints/mobilefacenet.pth', map_location='cuda'),
strict=False)
self.generator = Generator().cuda()
self.discriminator = Discriminator().cuda()
self.adversarial_weight = 1
self.src_id_weight = 5
self.tgt_id_weight = 1
self.attributes_weight = 10
self.reconstruction_weight = 10
self.lr = lr
self.warmup = warmup
self.g_optimizer = g_optimizer(self.generator.parameters(),
lr=lr,
betas=(0, 0.999))
self.d_optimizer = d_optimizer(self.discriminator.parameters(),
lr=lr,
betas=(0, 0.999))
self.generator, self.g_optimizer = amp.initialize(self.generator,
self.g_optimizer,
opt_level="O1")
self.discriminator, self.d_optimizer = amp.initialize(
self.discriminator, self.d_optimizer, opt_level="O1")
self._iter = nn.Parameter(torch.tensor(1), requires_grad=False)
self.max_iters = max_iters
if torch.cuda.is_available():
self.cuda()
def new(self):
print('Creating a new model...')
generator = Generator(self.resolution, self.batch_size, depth=12)
discriminator = Discriminator(self.resolution, depth=12)
lr = 5e-5
generator.model.optimizer = keras.optimizers.RMSprop(lr)
discriminator.model.optimizer = keras.optimizers.RMSprop(lr)
self.restored = False
self.initialize(generator, discriminator)
def get_system(name, args, schema=None, timed=False):
lexicon = Lexicon(schema.values['owner'])
if name == 'rulebased':
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
elif name == 'cmd':
return CmdSystem()
# elif name == 'neural':
# return NeuralSystem(args.model_file, args.temperature, timed_session=timed, gpu=args.gpu)
else:
raise ValueError('Unknown system %s' % name)
def __init__(self, properties: SimulationProperties):
self.__stats = Stats(properties.num_sources, properties.num_devices)
self.__generators = [
Generator(i, l, self.__stats)
for i, l in enumerate(properties.source_lambdas)
]
self.__devices = [
Device(i, t, self.__stats)
for i, t in enumerate(properties.device_taus)
]
self.__buffer = Buffer(properties.buffer_capacity, self.__stats)
self.__max_requests = properties.max_requests
self.__global_time = 0
def generate_fakes(config_path, num_fake_batches, checkpoint_dir, generated_images_dir):
cfg = ModelConfig(config_path)
discriminator = Discriminator(cfg)
generator = Generator(cfg)
# Initialize models
generator(tf.ones([cfg.batch_size, cfg.latent_size]), tf.ones([cfg.batch_size, cfg.labels_size]))
discriminator(tf.ones([cfg.batch_size, cfg.resolution, cfg.resolution,
cfg.num_channels]), tf.ones([cfg.batch_size, cfg.labels_size]))
# Initialize checkpoint and manager
checkpoint = tf.train.Checkpoint(discriminator=discriminator, generator=generator)
manager = tf.train.CheckpointManager(
checkpoint, checkpoint_dir, max_to_keep=10)
if cfg.label_conditioning:
fake_labels = np.zeros([cfg.batch_size, cfg.labels_size], dtype=np.float32)
fake_labels[np.arange(cfg.batch_size), np.random.randint(cfg.labels_size, size=cfg.batch_size)] = 1.0
random_input = tf.random.normal([cfg.batch_size, cfg.latent_size])
for checkpoint_path in manager.checkpoints:
print('Restoring checkpoint from {}'.format(checkpoint_path))
checkpoint.restore(checkpoint_path).assert_consumed()
fake_image_batches = []
fake_labels_batches = []
for _ in range(num_fake_batches):
if cfg.label_conditioning:
fake_labels_batch = np.zeros([cfg.batch_size, cfg.labels_size], dtype=np.float32)
fake_labels_batch[np.arange(cfg.batch_size), np.random.randint(
cfg.labels_size, size=cfg.batch_size)] = 1.0
else:
fake_labels_batch = None
random_input = tf.random.normal([cfg.batch_size, cfg.latent_size])
fake_images_batch = generator(random_input, fake_labels_batch)
fake_image_batches.append(fake_images_batch)
fake_labels_batches.append(fake_labels_batch)
fake_images = np.concatenate(fake_image_batches, axis=0)
if cfg.label_conditioning:
fake_labels = np.concatenate(fake_labels_batches, axis=0)
else:
fake_labels = None
if not os.path.exists(generated_images_dir):
os.makedirs(generated_images_dir)
plot_batch(fake_images, fake_labels, generated_images_dir + '/checkpoint-' +
checkpoint_path.split('-')[-1], cfg.label_conditioning)
def init_single_layer_gan(self):
generator = Generator(self.config).to(self.config.device)
generator.apply(weights_init)
if self.config.generator_path is not None:
generator.load_state_dict(torch.load(self.config.generator_path))
# print(generator)
discriminator = ACMDiscriminator(self.config, self.config.num_heads, self.reals[len(self.Gs)]).to(self.config.device)
discriminator.apply(weights_init)
if self.config.discriminator_path is not None:
discriminator.load_state_dict(torch.load(self.config.discriminator_path))
print(discriminator)
return discriminator, generator
def get_system(name, args, schema=None, timed=False, model_path=None):
lexicon = Lexicon(schema.values['item'])
if name == 'rulebased':
templates = Templates.from_pickle(args.templates)
generator = Generator(templates)
manager = Manager.from_pickle(args.policy)
return RulebasedSystem(lexicon, generator, manager, timed)
elif name == 'hybrid':
assert model_path
templates = Templates.from_pickle(args.templates)
manager = PytorchNeuralSystem(args, schema, lexicon, model_path, timed)
generator = Generator(templates)
return HybridSystem(lexicon, generator, manager, timed)
elif name == 'cmd':
return CmdSystem()
elif name == 'fb-neural':
assert model_path
return FBNeuralSystem(model_path, args.temperature, timed_session=timed, gpu=False)
elif name == 'pt-neural':
assert model_path
return PytorchNeuralSystem(args, schema, lexicon, model_path, timed)
else:
raise ValueError('Unknown system %s' % name)
def build_base_component(self):
# hyper params
self.lr = tf.placeholder(tf.float32, shape=(),
name='lr') # learning rate
self.dropout = tf.placeholder(tf.float32, shape=(), name='dropout')
# input of the graph
self.img = tf.placeholder(tf.uint8,
shape=(None, None, None, 1),
name='img') # (N, H, W, C)，这里C=1，因为是灰度图
self.formula = tf.placeholder(tf.int32,
shape=(None, None),
name='formula') # (N, formula_tokens)
self.formula_length = tf.placeholder(tf.int32,
shape=(None, ),
name='formula_length') # (N, 1)
# self.pred_train, self.pred_test
# tensorflow 只有静态计算图，只好同时把 train 和 test 部分的计算图都建了
self.generator = Generator(self._config, self._vocab.n_tok,
self._vocab.id_end)
train, test = self.generator(self.img, self.formula, self.dropout)
self.pred_train = train
self.pred_test = test
self.discriminator = Discriminator(self._config, self._vocab.n_tok)
self.D_loss = self.discriminator(self.pred_test.ids, self.formula,
self.dropout)
self.D_optimizer = tf.train.AdamOptimizer().minimize(self.D_loss)
# self.loss 生成器第一阶段的 loss
losses = tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=self.pred_train, labels=self.formula)
mask = tf.sequence_mask(self.formula_length)
losses = tf.boolean_mask(losses, mask)
self.loss = tf.reduce_mean(losses)
# to compute perplexity for test
self.ce_words = tf.reduce_sum(losses) # sum of CE for each word
self.n_words = tf.reduce_sum(self.formula_length) # number of words
# tensorboard
tf.summary.image("img", self.img)
tf.summary.scalar("learning_rate", self.lr)
tf.summary.scalar("dropout", self.dropout)
tf.summary.scalar("G_loss", self.loss)
tf.summary.scalar("D_loss", self.D_loss)
tf.summary.scalar("sum_of_CE_for_each_word", self.ce_words)
tf.summary.scalar("number_of_words", self.n_words)
def init(config, checkpoint_path, device="cuda"):
checkpoint = torch.load(checkpoint_path)
if config is not None:
hp = HParam(config)
else:
hp = load_hparam_str(checkpoint['hp_str'])
model = Generator(hp.audio.n_mel_channels,
hp.model.n_residual_layers,
ratios=hp.model.generator_ratio,
mult=hp.model.mult,
out_band=hp.model.out_channels).to(device)
model.load_state_dict(checkpoint['model_g'])
model.eval(inference=True)
return hp, model
def init_models(self):
generator = Generator(self.config).to(self.config.device)
generator.apply(weights_init)
if self.config.generator_path is not None:
generator.load_state_dict(torch.load(self.config.generator_path))
# print(generator)
discriminator = Discriminator(self.config).to(self.config.device)
discriminator.apply(weights_init)
if self.config.discriminator_path is not None:
discriminator.load_state_dict(
torch.load(self.config.discriminator_path))
# print(discriminator)
return discriminator, generator
