def evaluate(hps, generator, eval_loader, writer_eval):
generator.eval()
with torch.no_grad():
for batch_idx, (spec, spec_lengths, y, y_lengths) in enumerate(eval_loader):
spec, spec_lengths = spec.cuda(0), spec_lengths.cuda(0)
y, y_lengths = y.cuda(0), y_lengths.cuda(0)
# remove else
spec = spec[:1]
spec_lengths = spec_lengths[:1]
y = y[:1]
y_lengths = y_lengths[:1]
break
mel = spec_to_mel_torch(
spec,
hps.data.filter_length,
hps.data.n_mel_channels,
hps.data.sampling_rate,
hps.data.mel_fmin,
hps.data.mel_fmax)
y_hat, mask, *_ = generator.module.infer(mel, spec_lengths, max_len=1000)
y_hat_lengths = mask.sum([1,2]).long() * hps.data.hop_length
mel = spec_to_mel_torch(
spec,
hps.data.filter_length,
hps.data.n_mel_channels,
hps.data.sampling_rate,
hps.data.mel_fmin,
hps.data.mel_fmax)
y_hat_mel = mel_spectrogram_torch(
y_hat.squeeze(1).float(),
hps.data.filter_length,
hps.data.n_mel_channels,
hps.data.sampling_rate,
hps.data.hop_length,
hps.data.win_length,
hps.data.mel_fmin,
hps.data.mel_fmax
)
image_dict = {
"gen/mel": utils.plot_spectrogram_to_numpy(y_hat_mel[0].cpu().numpy())
}
audio_dict = {
"gen/audio": y_hat[0,:,:y_hat_lengths[0]]
}
if global_step == 0:
image_dict.update({"gt/mel": utils.plot_spectrogram_to_numpy(mel[0].cpu().numpy())})
audio_dict.update({"gt/audio": y[0,:,:y_lengths[0]]})
utils.summarize(
writer=writer_eval,
global_step=global_step,
images=image_dict,
audios=audio_dict,
audio_sampling_rate=hps.data.sampling_rate
)
generator.train()
def evaluate(rank, epoch, hps, generator, optimizer_g, val_loader, logger,
writer_eval):
if rank == 0:
global global_step
generator.eval()
losses_tot = []
with torch.no_grad():
for batch_idx, (x, x_lengths, y,
y_lengths) in enumerate(val_loader):
x, x_lengths = x.cuda(rank, non_blocking=True), x_lengths.cuda(
rank, non_blocking=True)
y, y_lengths = y.cuda(rank, non_blocking=True), y_lengths.cuda(
rank, non_blocking=True)
(z, y_m, y_logs,
logdet), attn, logw, logw_, x_m, x_logs = generator(x,
x_lengths,
y,
y_lengths,
gen=False)
l_mle = 0.5 * math.log(2 * math.pi) + (
torch.sum(y_logs) +
0.5 * torch.sum(torch.exp(-2 * y_logs) *
(z - y_m)**2) - torch.sum(logdet)
) / (torch.sum(y_lengths // hps.model.n_sqz) *
hps.model.n_sqz * hps.data.n_mel_channels)
l_length = torch.sum((logw - logw_)**2) / torch.sum(x_lengths)
loss_gs = [l_mle, l_length]
loss_g = sum(loss_gs)
if batch_idx == 0:
losses_tot = loss_gs
else:
losses_tot = [x + y for (x, y) in zip(losses_tot, loss_gs)]
if batch_idx % hps.train.log_interval == 0:
logger.info(
'Eval Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.
format(epoch, batch_idx * len(x),
len(val_loader.dataset),
100. * batch_idx / len(val_loader),
loss_g.item()))
logger.info([x.item() for x in loss_gs])
losses_tot = [x / len(val_loader) for x in losses_tot]
loss_tot = sum(losses_tot)
scalar_dict = {"loss/g/total": loss_tot}
scalar_dict.update(
{"loss/g/{}".format(i): v
for i, v in enumerate(losses_tot)})
utils.summarize(writer=writer_eval,
global_step=global_step,
scalars=scalar_dict)
logger.info('====> Epoch: {}'.format(epoch))
def isolated_obj_scenario(n, vis, output, debug):
objects = YcbObjects(
'objects/ycb_objects',
mod_orn=['ChipsCan', 'MustardBottle', 'TomatoSoupCan'],
mod_stiffness=['Strawberry'])
data = IsolatedObjData(objects.obj_names, n, 'results')
center_x, center_y = 0.05, -0.52
network_path = 'network/trained-models/cornell-randsplit-rgbd-grconvnet3-drop1-ch32/epoch_19_iou_0.98'
camera = Camera((center_x, center_y, 1.9), (center_x, center_y, 0.785),
0.2, 2.0, (224, 224), 40)
env = Environment(camera, vis=vis, debug=debug)
generator = GraspGenerator(network_path, camera, 5)
for obj_name in objects.obj_names:
print(obj_name)
for _ in range(n):
path, mod_orn, mod_stiffness = objects.get_obj_info(obj_name)
env.load_isolated_obj(path, mod_orn, mod_stiffness)
env.move_away_arm()
rgb, depth, _ = camera.get_cam_img()
grasps, save_name = generator.predict_grasp(rgb,
depth,
n_grasps=3,
show_output=output)
for i, grasp in enumerate(grasps):
data.add_try(obj_name)
x, y, z, roll, opening_len, obj_height = grasp
if vis:
debug_id = p.addUserDebugLine([x, y, z], [x, y, 1.2],
[0, 0, 1])
succes_grasp, succes_target = env.grasp(
(x, y, z), roll, opening_len, obj_height)
if vis:
p.removeUserDebugItem(debug_id)
if succes_grasp:
data.add_succes_grasp(obj_name)
if succes_target:
data.add_succes_target(obj_name)
if save_name is not None:
os.rename(save_name + '.png',
save_name + f'_SUCCESS_grasp{i}.png')
break
env.reset_all_obj()
env.remove_all_obj()
data.write_json()
summarize(data.save_dir, n)
def train(rank, epoch, hps, generator, optimizer_g, train_loader, logger, writer):
train_loader.sampler.set_epoch(epoch)
global global_step
generator.train()
for batch_idx, (x, x_lengths, y, y_lengths) in enumerate(train_loader):
x, x_lengths = x.cuda(rank, non_blocking=True), x_lengths.cuda(rank, non_blocking=True)
y, y_lengths = y.cuda(rank, non_blocking=True), y_lengths.cuda(rank, non_blocking=True)
# Train Generator
optimizer_g.zero_grad()
(z, y_m, y_logs, logdet), attn, logw, logw_, x_m, x_logs = generator(x, x_lengths, y, y_lengths, gen=False)
l_mle = 0.5 * math.log(2 * math.pi) + (torch.sum(y_logs) + 0.5 * torch.sum(torch.exp(-2 * y_logs) * (z - y_m)**2) - torch.sum(logdet)) / (torch.sum(y_lengths // hps.model.n_sqz) * hps.model.n_sqz * hps.data.n_mel_channels)
l_length = torch.sum((logw - logw_)**2) / torch.sum(x_lengths)
loss_gs = [l_mle, l_length]
loss_g = sum(loss_gs)
if hps.train.fp16_run:
with amp.scale_loss(loss_g, optimizer_g._optim) as scaled_loss:
scaled_loss.backward()
grad_norm = commons.clip_grad_value_(amp.master_params(optimizer_g._optim), 5)
else:
loss_g.backward()
grad_norm = commons.clip_grad_value_(generator.parameters(), 5)
optimizer_g.step()
if rank==0:
if batch_idx % hps.train.log_interval == 0:
(y_gen, *_), *_ = generator.module(x[:1], x_lengths[:1], gen=True)
logger.info('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, batch_idx * len(x), len(train_loader.dataset),
100. * batch_idx / len(train_loader),
loss_g.item()))
logger.info([x.item() for x in loss_gs] + [global_step, optimizer_g.get_lr()])
scalar_dict = {"loss/g/total": loss_g, "learning_rate": optimizer_g.get_lr(), "grad_norm": grad_norm}
scalar_dict.update({"loss/g/{}".format(i): v for i, v in enumerate(loss_gs)})
utils.summarize(
writer=writer,
global_step=global_step,
images={"y_org": utils.plot_spectrogram_to_numpy(y[0].data.cpu().numpy()),
"y_gen": utils.plot_spectrogram_to_numpy(y_gen[0].data.cpu().numpy()),
"attn": utils.plot_alignment_to_numpy(attn[0,0].data.cpu().numpy()),
},
scalars=scalar_dict)
global_step += 1
if rank == 0:
logger.info('====> Epoch: {}'.format(epoch))
def evaluate(rank, epoch, hps, generator, optimizer_g, val_loader, logger,
writer_eval):
if rank == 0:
global global_step
generator.eval()
losses_tot = []
with torch.no_grad():
for batch_idx, (x, x_lengths, y,
y_lengths) in enumerate(val_loader):
x, x_lengths = x.cuda(rank, non_blocking=True), x_lengths.cuda(
rank, non_blocking=True)
y, y_lengths = y.cuda(rank, non_blocking=True), y_lengths.cuda(
rank, non_blocking=True)
(z, z_m, z_logs, logdet,
z_mask), (x_m, x_logs, x_mask), (attn, logw,
logw_) = generator(x,
x_lengths,
y,
y_lengths,
gen=False)
l_mle = commons.mle_loss(z, z_m, z_logs, logdet, z_mask)
l_length = commons.duration_loss(logw, logw_, x_lengths)
loss_gs = [l_mle, l_length]
loss_g = sum(loss_gs)
if batch_idx == 0:
losses_tot = loss_gs
else:
losses_tot = [x + y for (x, y) in zip(losses_tot, loss_gs)]
if batch_idx % hps.train.log_interval == 0:
logger.info(
'Eval Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.
format(epoch, batch_idx * len(x),
len(val_loader.dataset),
100. * batch_idx / len(val_loader),
loss_g.item()))
logger.info([x.item() for x in loss_gs])
losses_tot = [x / len(val_loader) for x in losses_tot]
loss_tot = sum(losses_tot)
scalar_dict = {"loss/g/total": loss_tot}
scalar_dict.update(
{"loss/g/{}".format(i): v
for i, v in enumerate(losses_tot)})
utils.summarize(writer=writer_eval,
global_step=global_step,
scalars=scalar_dict)
logger.info('====> Epoch: {}'.format(epoch))
def __getitem__(self, tuple_of_arguments):
filter_applied = tuple_of_arguments[0]
funcs = tuple_of_arguments[1]
old_return_fixed_indices = filter_applied.return_fixed_indices
filter_applied.return_fixed_indices = True
indices_that_exist, fixed_indices = filter_applied.apply(self._data)
filter_applied.return_fixed_indices = old_return_fixed_indices
column_names = tuple_of_arguments[2] if len(tuple_of_arguments) > 2 else None
if column_names is None:
column_names = list(self._data.columns.values)
summaries = [summarize(self._data.loc[x[0]:x[1]][column_names], funcs) for
x in zip(fixed_indices[:-1], fixed_indices[1:])]
summary = functools.reduce(lambda df1, df2: pd.concat([df1, df2], ignore_index=False), summaries)
summary["End_Period"] = fixed_indices[:-1]
summary["Start_Period"] = fixed_indices[1:]
summary.set_index('Start_Period', inplace=True)
if not isinstance(summary, type(self._data)):
raise TypeError(
f'Interval Call to DataProcessor should return type {type(self._data)} but returned {type(summary)}')
# if one wishes to rename the column names that can be done through another __call__
return DataProcessor(summary)
def create_summary_by_zone(zones):
"""
Creates summary file in zone folder
Args:
zones (iterable): Zone number
"""
for zone in zones:
zone_path, zone_file_prefix = get_zone_output_path(zone, data_path)
df_avail, df_order, df_steer, df_cap = load_data_file_for_zone(
zone, data_path)
slots_observed, cslots_observed = get_slots_observed(
zone_path,
zone_file_prefix,
df_avail,
df_order.columns,
check_existing=False)
slots_active, cslots_active, slots_offered, cslots_offered = get_slots_active(
zone_path, zone_file_prefix, df_order, slots_observed)
summary = summarize(zone_path, zone_file_prefix, df_avail, df_order,
df_steer, df_cap, slots_offered, cslots_offered)
summary = summary.reset_index()
summary['EVENT_DTM'] = pd.to_datetime(summary['EVENT_DTM'])
plot_arrivals(zone_path, zone_file_prefix, summary, '60min', 'mean',
'ALL')
def group_sentences(grouping):
analyzer = SentimentIntensityAnalyzer()
sentences = []
sources = set()
for article in grouping:
summarized = summarize(article.content, 15)
processed_summarized = []
for sentence in summarized:
sources.add(article.source)
processed_summarized.append((sentence, "source " + article.source))
sentences.extend(processed_summarized)
common = common_keywords(grouping)
scoring = []
for sentence in sentences:
final_score = 0
score = analyzer.polarity_scores(sentence[0])
for word in common:
if word in sentence[0]:
final_score += abs(score["compound"] - common[word])
scoring.append((sentence, final_score))
scoring = sorted(scoring, key=lambda x: x[1])[0:10]
scoring = [sentence[0] for sentence in scoring]
final_output = []
for sentence in sentences:
if sentence in scoring:
final_output.append(sentence)
return final_output, sources
def __init__(self, content, source):
self.content = content
self.source = source
self.sentences = split_sentences(content)
self.vector = vectorize_text(content)
self.word_scores = {}
self.summary = summarize(self.content, 7)
self.init_word_scores()
def evaluate(hps, model, eval_loader, writer_eval):
model.eval()
with torch.no_grad():
for batch_idx, (img, txt, mask_img, mask_txt, pos_r, pos_c,
pos_t) in enumerate(eval_loader):
img = img.cuda(0, non_blocking=True)
txt = txt.cuda(0, non_blocking=True)
mask_img = mask_img.cuda(0, non_blocking=True)
mask_txt = mask_txt.cuda(0, non_blocking=True)
pos_r = pos_r.cuda(0, non_blocking=True)
pos_c = pos_c.cuda(0, non_blocking=True)
pos_t = pos_t.cuda(0, non_blocking=True)
img_i = img[:, :-1]
img_o = img[:, 1:]
txt_i = txt[:, :-1]
txt_o = txt[:, 1:]
mask_img_i = mask_img[:, :-1]
mask_img_o = mask_img[:, 1:]
mask_txt_i = mask_txt[:, :-1]
mask_txt_o = mask_txt[:, 1:, 0]
with autocast(enabled=hps.train.fp16_run):
logits_img, logits_txt = model(img_i, txt_i, mask_img_i,
mask_txt_i, pos_r, pos_c, pos_t)
with autocast(enabled=False):
loss_img = loss_fn_img(logits_img, img_o, mask_img_o)
loss_txt = loss_fn_txt(logits_txt, txt_o, mask_txt_o)
loss_tot = loss_img * hps.train.lamb + loss_txt
break
scalar_dict = {
"loss/total": loss_tot.item(),
"loss/img": loss_img.item(),
"loss/txt": loss_txt.item()
}
utils.summarize(
writer=writer_eval,
global_step=global_step,
scalars=scalar_dict,
)
model.train()
def visualize(vectorizer, data=None):
data = get_data(p.VAL_FILE,
vectorizer,
with_oov=p.POINTER_GEN,
aspect_file=p.ASPECT_FILE) if data is None else data
model = new_model(vectorizer, data.dataset.aspects).eval()
with open(p.MODEL_FILE, 'rb') as modelfile:
model.load_state_dict(pkl.load(modelfile))
batch = data[271:271 + p.DECODING_BATCH_SIZE]
aspect_results = summarize(batch, model, beam_size=p.BEAM_SIZE)
print_batch(batch, [r[0] for r in aspect_results], vectorizer,
model.aspects)
vis(p.VISUALIZATION_FILE,
batch, [r[0] for r in aspect_results],
vectorizer,
model.aspects,
0,
0,
pointer_gen=p.POINTER_GEN)
def article(request, pk):
cache_name = 'newscache:{}{}'.format('article', str(pk))
icache = 'infinitecache:{}{}'.format('article', str(pk))
response = cache.get(cache_name, None)
if response:
return response
pk = int(pk)
context = {}
if request.method == 'GET':
try:
articles = mongo_calls('migrations')
article = articles.find_one(
{'article_id': pk},
{'headline': 1, 'category': 1, 'writer': 1, 'summary': 1,
'keywords': 1, 'content': 1, 'photo': 1, 'posted': 1})
aUri = HttpRequest.build_absolute_uri(request)
try:
article['posted'] = datetime.fromtimestamp(
article['posted'])
except Exception:
pass
if article.get('summary'):
article['par1'] = article['summary']
else:
article['par1'] = summarize(article)
context = {'article': article, 'aUri': aUri}
context['sUri'] = 'http://{}'.format(HttpRequest.get_host(request))
response = render(request, 'news/article.html', context)
cache.set(cache_name, response, 60*60*24)
cache.set(icache, response, 60*60*24*14)
return response
except Exception:
# Log exception
response = cache.get(icache, None)
return response
context['sUri'] = 'http://{}'.format(HttpRequest.get_host(request))
response = render(request, 'news/article.html', context)
return response
def compare(instance,
statistic,
summary,
nsim=50,
methods=[],
verbose=False,
htmlfile=None,
method_setup=True,
csvfile=None,
q=0.2):
results = []
run_CV = np.any([getattr(m, 'need_CV') for m in methods])
for method in methods:
if method_setup:
method.setup(instance.feature_cov, instance)
method.q = q
method_params, class_names, method_names = get_method_params(methods)
for i in range(nsim):
X, Y, beta = instance.generate()
# make a hash representing same data
instance_hash = hashlib.md5()
instance_hash.update(X.tobytes())
instance_hash.update(Y.tobytes())
instance_hash.update(beta.tobytes())
instance_id = instance_hash.hexdigest()
l_min, l_1se, l_theory, sigma_reid = gaussian_setup(X.copy(), Y.copy(), run_CV=run_CV)
for method, method_name, class_name, idx in zip(methods,
method_names,
class_names,
range(len(methods))):
if verbose:
print('method:', method)
M, result_df = statistic(method, instance, X.copy(), Y.copy(), beta.copy(), l_theory.copy(), l_min, l_1se, sigma_reid)
if result_df is not None:
result_df['instance_id'] = instance_id
result_df['method_param'] = str(method_params.loc[idx])
result_df['model_target'] = M.model_target
result_df['method_name'] = method_name
result_df['class_name'] = class_name
results.append(result_df)
else:
print('Result was empty.')
if i > 0 and len(results) > 0:
results_df = pd.concat(results)
for p in instance.params.columns:
results_df[p] = instance.params[p][0]
if csvfile is not None:
f = open(csvfile, 'w')
f.write(results_df.to_csv(index_label=False) + '\n')
f.close()
summary_df = summarize('method_param',
results_df,
summary)
for p in instance.params.columns:
summary_df[p] = instance.params[p][0]
if htmlfile is not None:
f = open(htmlfile, 'w')
f.write(summary_df.to_html() + '\n')
f.write(instance.params.to_html())
f.close()
# also write a summary CSV
f = open(csvfile.replace('.csv', '_summary.csv'), 'w')
f.write(summary_df.to_csv(index_label=False) + '\n')
f.close()
def train(sess, args, config):
model_type = config.get('config', 'experiment')
base_dir = os.path.expanduser(config.get('config', 'basedir'))
tfrecord_dir = os.path.join(base_dir, config.get(model_type, 'tfrecord'))
log_dir = os.path.join(base_dir, config.get('config', 'logdir'))
adversarial_mode = config.get('config', 'mode')
whether_noise = config.getboolean('generator', 'noise')
t2s_task = config.getboolean('config', 't2s_task')
noise_dim = config.getint('generator', 'noise_dim')
source_only = config.getboolean('config', 'source_only')
s2t_adversarial_weight = config.getfloat(model_type, 's2t_adversarial_weight')
t2s_adversarial_weight = config.getfloat(model_type, 't2s_adversarial_weight')
s2t_cyclic_weight = config.getfloat(model_type, 's2t_cyclic_weight')
t2s_cyclic_weight = config.getfloat(model_type, 't2s_cyclic_weight')
s2t_task_weight = config.getfloat(model_type, 'task_weight')
t2s_task_weight = config.getfloat(model_type, 't2s_task_weight')
s2t_style_weight = config.getfloat(model_type, 's2t_style_weight')
t2s_style_weight = config.getfloat(model_type, 't2s_style_weight')
discriminator_step = config.getint(model_type, 'discriminator_step')
generator_step = config.getint(model_type, 'generator_step')
save_dir = os.path.join(log_dir, utils.make_savedir(config))
# save_dir = os.path.join(log_dir, config.get('config', 'savedir'))
if args.delete and os.path.exists(save_dir):
shutil.rmtree(save_dir)
os.makedirs(save_dir, exist_ok=True)
model_path = importlib.import_module(model_type)
model = getattr(model_path, 'model')
da_model = model(args, config)
writer = tf.summary.FileWriter(save_dir, sess.graph)
global_step = tf.train.get_or_create_global_step()
get_batches = getattr(dataset_utils, model_type)
tf.logging.info('Training %s with %s' % (model_type, adversarial_mode))
if model_type == 'da_cil':
with tf.name_scope(model_type + '_batches'):
source_image_batch, source_label_batch, source_measure_batch, source_command_batch = get_batches('source', 'train', tfrecord_dir, batch_size=args.batch_size, config=config, args=args)
if source_only:
da_model(source_image_batch, None, source_measure_batch)
else:
target_image_batch, _, _, _ = get_batches('target', 'train', tfrecord_dir, batch_size=args.batch_size, config=config, args=args)
da_model(source_image_batch, target_image_batch, source_measure_batch)
with tf.name_scope(model_type + '_objectives'):
da_model.create_objective(source_label_batch, source_command_batch, adversarial_mode)
if source_only:
discriminator_loss = da_model.task_loss
da_model.summary['discriminator_loss'] = discriminator_loss
else:
generator_loss = s2t_cyclic_weight * da_model.s2t_cyclic_loss + t2s_cyclic_weight * da_model.t2s_cyclic_loss + da_model.s2t_adversarial_loss[0] + da_model.t2s_adversarial_loss[0]
generator_loss += s2t_style_weight * da_model.s2t_style_loss + t2s_style_weight * da_model.t2s_style_loss
da_model.summary['generator_loss'] = generator_loss
discriminator_loss = s2t_adversarial_weight * da_model.s2t_adversarial_loss[1] + t2s_adversarial_weight * da_model.t2s_adversarial_loss[1] + s2t_task_weight * da_model.task_loss
if t2s_task:
discriminator_loss += t2s_task_weight * da_model.t2s_task_loss
da_model.summary['discriminator_loss'] = discriminator_loss
elif model_type == 'pixel_da':
with tf.name_scope(model_type + '_batches'):
source_image_batch, source_label_batch = get_batches('source', 'train', tfrecord_dir, batch_size=args.batch_size, config=config)
mask_image_batch = source_image_batch[:,:,:,3]
source_image_batch = source_image_batch[:,:,:,:3]
if config.getboolean(model_type, 'input_mask'):
tf.logging.info('Using masked input')
mask_images = tf.to_float(tf.greater(mask_image_batch, 0.9))
source_image_batch = tf.multiply(source_image_batch, tf.tile(tf.expand_dims(mask_images, 3), [1,1,1,3]))
# Label is already an 1-hot labels, but we expect categorical
source_label_max_batch = tf.argmax(source_label_batch, 1)
source_lateral_label_batch = (source_label_max_batch % 9) / 3
source_head_label_batch = source_label_max_batch % 3
target_image_batch, _ = get_batches('target', 'train', tfrecord_dir, batch_size=args.batch_size, config=config)
da_model(source_image_batch, target_image_batch)
with tf.name_scope(model_type + '_objectives'):
da_model.create_objective(source_head_label_batch, source_lateral_label_batch, adversarial_mode)
generator_loss = s2t_cyclic_weight * da_model.s2t_cyclic_loss + t2s_cyclic_weight * da_model.t2s_cyclic_loss + da_model.s2t_adversarial_loss[0] + da_model.t2s_adversarial_loss[0]
generator_loss += s2t_style_weight * da_model.s2t_style_loss + t2s_style_weight * da_model.t2s_style_loss
da_model.summary['generator_loss'] = generator_loss
discriminator_loss = s2t_adversarial_weight * da_model.s2t_adversarial_loss[1] + t2s_adversarial_weight * da_model.t2s_adversarial_loss[1] + s2t_task_weight * da_model.transferred_task_loss
if t2s_task:
discriminator_loss += t2s_task_weight * da_model.t2s_task_loss
da_model.summary['discriminator_loss'] = discriminator_loss
else:
raise Exception('Not supported model')
with tf.name_scope('optimizer'):
tf.logging.info('Getting optimizer')
if args.lr_decay:
decay_steps = config.getint('optimizer', 'decay_steps')
decay_rate = config.getfloat('optimizer', 'decay_rate')
learning_rate = tf.train.exponential_decay(args.learning_rate, global_step, decay_steps, decay_rate, staircase=True)
else:
learning_rate = args.learning_rate
if not source_only:
g_optimizer = _get_optimizer(config, args.optimizer)(learning_rate)
g_optim = _gradient_clip(name='generator', optimizer=g_optimizer, loss=generator_loss, global_steps=global_step, clip_norm=args.clip_norm)
d_optimizer = _get_optimizer(config, args.optimizer)(learning_rate)
d_optim = _gradient_clip(name='discriminator', optimizer=d_optimizer, loss=discriminator_loss, global_steps=global_step, clip_norm=args.clip_norm)
if not source_only:
generator_summary, discriminator_summary = utils.summarize(da_model.summary, t2s_task)
utils.config_summary(save_dir, s2t_adversarial_weight, t2s_adversarial_weight, s2t_cyclic_weight, t2s_cyclic_weight, s2t_task_weight, t2s_task_weight, discriminator_step, generator_step, adversarial_mode, whether_noise, noise_dim, s2t_style_weight, t2s_style_weight)
else:
discriminator_summary = utils.summarize(da_model.summary, t2s_task, source_only)
saver = tf.train.Saver(max_to_keep=5)
sess.run(tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()))
if args.load_ckpt:
ckpt = tf.train.get_checkpoint_state(save_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess, coord)
try:
for iter_count in range(args.max_iter):
# Update discriminator
for disc_iter in range(discriminator_step):
d_loss, _, steps = sess.run([discriminator_loss, d_optim, global_step])
if not source_only and adversarial_mode == 'FISHER':
_, _ = sess.run([da_model.s2t_adversarial_loss[-1], da_model.t2s_adversarial_loss[-1]])
#writer.add_summary(disc_sum, steps)
tf.logging.info('Step %d: Discriminator loss=%.5f', steps, d_loss)
if not source_only:
for gen_iter in range(generator_step):
g_loss, _, steps = sess.run([generator_loss, g_optim, global_step])
#writer.add_summary(gen_sum, steps)
tf.logging.info('Step %d: Generator loss=%.5f', steps, g_loss)
if (iter_count+1) % args.save_interval == 0:
saver.save(sess, os.path.join(save_dir, model_type), global_step=(iter_count+1))
tf.logging.info('Checkpoint save')
if (iter_count+1) % args.summary_interval == 0:
if not source_only:
disc_sum, gen_sum = sess.run([discriminator_summary, generator_summary])
writer.add_summary(gen_sum, steps)
else:
disc_sum = sess.run(discriminator_summary)
writer.add_summary(disc_sum, steps)
tf.logging.info('Summary at %d step' % (iter_count+1))
except tf.errors.OutOfRangeError:
print('Epoch limited')
except KeyboardInterrupt:
print('End training')
finally:
coord.request_stop()
coord.join(threads)
def train_and_evaluate(rank, epoch, hps, model, optim, scaler, loaders,
writers):
train_loader, eval_loader = loaders
if writers is not None:
writer, writer_eval = writers
train_loader.batch_sampler.set_epoch(epoch)
global global_step
model.train()
for batch_idx, (img, txt, mask_img, mask_txt, pos_r, pos_c,
pos_t) in enumerate(train_loader):
img = img.cuda(rank, non_blocking=True)
txt = txt.cuda(rank, non_blocking=True)
mask_img = mask_img.cuda(rank, non_blocking=True)
mask_txt = mask_txt.cuda(rank, non_blocking=True)
pos_r = pos_r.cuda(rank, non_blocking=True)
pos_c = pos_c.cuda(rank, non_blocking=True)
pos_t = pos_t.cuda(rank, non_blocking=True)
img_i = img[:, :-1]
img_o = img[:, 1:]
txt_i = txt[:, :-1]
txt_o = txt[:, 1:]
mask_img_i = mask_img[:, :-1]
mask_img_o = mask_img[:, 1:]
mask_txt_i = mask_txt[:, :-1]
mask_txt_o = mask_txt[:, 1:, 0]
with autocast(enabled=hps.train.fp16_run):
logits_img, logits_txt = model(img_i, txt_i, mask_img_i,
mask_txt_i, pos_r, pos_c, pos_t)
with autocast(enabled=False):
loss_img = loss_fn_img(logits_img, img_o, mask_img_o)
loss_txt = loss_fn_txt(logits_txt, txt_o, mask_txt_o)
loss_tot = loss_img * hps.train.lamb + loss_txt
optim.zero_grad()
scaler.scale(loss_tot).backward()
scaler.unscale_(optim)
grad_norm = commons.grad_norm(model.parameters())
scaler.step(optim)
scaler.update()
if rank == 0:
num_tokens = mask_img.sum() + mask_txt.sum()
if global_step % hps.train.log_interval == 0:
lr = optim.param_groups[0]['lr']
losses = [loss_tot, loss_img, loss_txt]
print('Train Epoch: {} [{:.0f}%]'.format(
epoch, 100. * batch_idx / len(train_loader)))
print([x.item() for x in losses] + [global_step, lr])
scalar_dict = {
"loss/total": loss_tot,
"loss/img": loss_img,
"loss/txt": loss_txt
}
scalar_dict.update({
"learning_rate": lr,
"grad_norm": grad_norm,
"num_tokens": num_tokens
})
utils.summarize(writer=writer,
global_step=global_step,
scalars=scalar_dict)
if global_step % hps.train.eval_interval == 0:
print("START: EVAL")
eval_loader.batch_sampler.set_epoch(global_step)
evaluate(hps, model, eval_loader, writer_eval)
utils.save_checkpoint(model, optim, hps.train.learning_rate,
epoch,
"model_{}.pth".format(global_step))
print("END: EVAL")
global_step += 1
if rank == 0:
print('====> Epoch: {}'.format(epoch))
def summary(self):
return summarize(self.content, MAX_SUMMARY_LENGTH)
def summary(self):
return utils.summarize(self.content, 50)
import utils
print("Welcome to NewsNow!")
choice = 'y'
while choice.lower() == 'y':
query = input("Enter query to search: ").lower()
links = utils.getLinks(query, 5)
articles = utils.getDocuments(links)
merged_article = utils.merge(articles)
summary = utils.summarize(merged_article)
print(f"Latest on {query}:\n{summary}\n")
choice = input("Search for another article? [y/n]: ")
raise ValueError('one should be rho, the other signal')
df = pd.read_csv(csvfile)
if opts.feature in ['power', 'fdr', 'selection_quality', 'conditional_power']:
summary = BH_summary # same as marginal_summary
elif opts.feature == 'risk':
summary = estimator_summary
elif opts.feature in ['coverage', 'mean_length', 'median_length', 'naive_length', 'median_strong_length']:
summary = interval_summary
else:
raise ValueError("don't know how to summarize '%s'" % opts.feature)
summary_df = summarize(['method_param',
opts.param,
opts.fixed],
df,
summary)
plot(summary_df,
opts.fixed,
opts.param,
{'power':'Full Model Power',
'selection_quality':'Selection Quality',
'fdr': 'Full Model FDR',
'risk': 'Risk',
'coverage': 'Coverage',
'mean_length': 'Mean Length',
'naive_length': 'Mean Naive Length',
'median_strong_length': 'Median Strong Length',
'conditional_power': 'Conditional Power',
def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, scaler, loaders, logger, writers):
net_g, net_d = nets
optim_g, optim_d = optims
scheduler_g, scheduler_d = schedulers
train_loader, eval_loader = loaders
if writers is not None:
writer, writer_eval = writers
train_loader.batch_sampler.set_epoch(epoch)
global global_step
net_g.train()
net_d.train()
for batch_idx, (spec, spec_lengths, y, y_lengths) in enumerate(train_loader):
spec, spec_lengths = spec.cuda(rank, non_blocking=True), spec_lengths.cuda(rank, non_blocking=True)
y, y_lengths = y.cuda(rank, non_blocking=True), y_lengths.cuda(rank, non_blocking=True)
with autocast(enabled=hps.train.fp16_run):
mel = spec_to_mel_torch(
spec,
hps.data.filter_length,
hps.data.n_mel_channels,
hps.data.sampling_rate,
hps.data.mel_fmin,
hps.data.mel_fmax)
# print('check',mel.shape)/
y_hat, ids_slice, x_mask, z_mask,\
(z, z_p, m_p, logs_p, m_q, logs_q) = net_g(mel, spec_lengths, spec, spec_lengths)
# print('check',log_det_j_sum.shape, m_p.shape)
y_mel = commons.slice_segments(mel, ids_slice, hps.train.segment_size // hps.data.hop_length)
y_hat_mel = mel_spectrogram_torch(
y_hat.squeeze(1),
hps.data.filter_length,
hps.data.n_mel_channels,
hps.data.sampling_rate,
hps.data.hop_length,
hps.data.win_length,
hps.data.mel_fmin,
hps.data.mel_fmax
)
y = commons.slice_segments(y, ids_slice * hps.data.hop_length, hps.train.segment_size) # slice
# NDA is effective?
batch_size=y.size(0)
y_jig1 = y.view(batch_size,4,-1)
rand_idx = torch.randperm(4)
y_jig2 = y_jig1[:,rand_idx,:]
y_jigsaw = y_jig2.view(batch_size,1,-1)
# print(rand_idx)
check_idx = torch.tensor([0,1,2,3])
if (rand_idx ==check_idx).sum()==4:
y_jigsaw = y_hat
else:
y_jigsaw = y_jigsaw
y_negative = 0.75*y_hat + 0.25*y_jigsaw
# Discriminator
y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_negative.detach())
with autocast(enabled=False):
loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(y_d_hat_r, y_d_hat_g)
loss_disc_all = loss_disc
optim_d.zero_grad()
scaler.scale(loss_disc_all).backward()
scaler.unscale_(optim_d)
grad_norm_d = commons.clip_grad_value_(net_d.parameters(), None)
scaler.step(optim_d)
with autocast(enabled=hps.train.fp16_run):
# Generator
y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = net_d(y, y_hat)
with autocast(enabled=False):
loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel
loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl
loss_fm = feature_loss(fmap_r, fmap_g)
loss_gen, losses_gen = generator_loss(y_d_hat_g)
loss_gen_all = loss_gen + loss_fm + loss_mel + loss_kl
optim_g.zero_grad()
scaler.scale(loss_gen_all).backward()
scaler.unscale_(optim_g)
grad_norm_g = commons.clip_grad_value_(net_g.parameters(), None)
scaler.step(optim_g)
scaler.update()
if rank==0:
if global_step % hps.train.log_interval == 0:
lr = optim_g.param_groups[0]['lr']
losses = [loss_disc, loss_gen, loss_fm, loss_mel, loss_kl]
logger.info('Train Epoch: {} [{:.0f}%]'.format(
epoch,
100. * batch_idx / len(train_loader)))
logger.info([x.item() for x in losses] + [global_step, lr])
scalar_dict = {"loss/g/total": loss_gen_all, "loss/d/total": loss_disc_all, "learning_rate": lr, "grad_norm_d": grad_norm_d, "grad_norm_g": grad_norm_g}
scalar_dict.update({"loss/g/fm": loss_fm, "loss/g/mel": loss_mel, "loss/g/kl": loss_kl})
scalar_dict.update({"loss/g/{}".format(i): v for i, v in enumerate(losses_gen)})
scalar_dict.update({"loss/d_r/{}".format(i): v for i, v in enumerate(losses_disc_r)})
scalar_dict.update({"loss/d_g/{}".format(i): v for i, v in enumerate(losses_disc_g)})
image_dict = {
"slice/mel_org": utils.plot_spectrogram_to_numpy(y_mel[0].data.cpu().numpy()),
"slice/mel_gen": utils.plot_spectrogram_to_numpy(y_hat_mel[0].data.cpu().numpy()),
"all/mel": utils.plot_spectrogram_to_numpy(mel[0].data.cpu().numpy()),
}
utils.summarize(
writer=writer,
global_step=global_step,
images=image_dict,
scalars=scalar_dict)
if global_step % hps.train.eval_interval == 0:
evaluate(hps, net_g, eval_loader, writer_eval)
utils.save_checkpoint(net_g, optim_g, hps.train.learning_rate, epoch, os.path.join(hps.model_dir, "G_{}.pth".format(global_step)))
utils.save_checkpoint(net_d, optim_d, hps.train.learning_rate, epoch, os.path.join(hps.model_dir, "D_{}.pth".format(global_step)))
global_step += 1
if rank == 0:
logger.info('====> Epoch: {}'.format(epoch))
