def main(args):
print('\nPreparing {} data'.format(args.dataset))
if args.dataset == 'mnist':
(X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_mnist()
elif args.dataset == 'cifar10':
(X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_cifar10()
elif args.dataset == 'cifar100':
(X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_cifar100()
print('\nConstruction graph')
if args.model == 'cnn_1':
env = cnn_1(args)
elif args.model == 'cnn_2':
env = cnn_2(args)
elif args.model == 'vgg16':
env = vgg16(args)
elif args.model == 'vgg19':
env = vgg19(args)
print('\nInitializing graph')
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
print('\nTraining')
name = '{0}_{1}'.format(args.model, args.dataset)
train(sess, env, X_train, y_train, X_valid, y_valid, batch_size=args.batch_size,
epochs=args.epochs, name=name)
print('\nEvaluating on clean data')
evaluate(sess, env, X_test, y_test)
def main():
os.environ['CUDA_VISIBLE_DEVICES'] = '7'
# init()
# acc_original = evaluate(model_checkpoint_path='log/model_dump/model.ckpt', has_bn=True,
# qweight=False, qactivation=False, image_norm=True)
# fix_input_params()
# acc_fix_input = evaluate(model_checkpoint_path='log/model_dump/model_fix_input.ckpt', has_bn=True,
# qweight=False, qactivation=False, image_norm=False)
# find_quantize_scale('log/model_dump/model_fix_input.ckpt')
# acc_int = evaluate(model_checkpoint_path='log/model_dump/model_fix_input.ckpt', has_bn=True,
# qweight=True, qactivation=True, image_norm=False)
bn_ema('log/model_dump/model_fix_input.ckpt',
qweight=True,
qactivation=True)
acc_int_bn_ema = evaluate(
model_checkpoint_path='log/model_dump/model_fix_input_bn_ema.ckpt',
has_bn=True,
qweight=True,
qactivation=True,
image_norm=False)
# print('float acc = %.3f%%' % acc_original)
# print('float fix input = %.3f%%' % acc_fix_input)
# print('int acc = %.3f%%' % acc_int)
print('int acc after bn ema = %.3f%%' % acc_int_bn_ema)
def reward(encoder_input,
encoder_label,
dim_indices,
vis_type,
reward_type,
with_label,
evaluate_tool=None,
label_num=0):
"""
Parameters
----------
encoder_input: torch.FloatTensor containing static (e.g. w, h) data (batch_size, sourceL, num_cities)
dim_indices: torch.IntTensor of size (batch_size, num_cities)
Returns
-------
Total Euclidean distance between neighbor dimensions. of size (batch_size, num_cities)
"""
use_cuda = encoder_input.is_cuda
data_num = encoder_input.shape[1]
dim_num = encoder_input.shape[2]
# batch_size x dim_num // dim_indices and expand as(static)
idx = dim_indices.unsqueeze(1).repeat(1, data_num, 1)
sample_input = torch.gather(encoder_input.data, 2, idx)
sample_label = torch.gather(encoder_label.data, 2, idx)
batch_size = sample_input.shape[0]
scores = torch.zeros(batch_size).detach()
if use_cuda:
scores = scores.cuda()
order = None
if evaluate_tool is None:
scores = tools.evaluate(sample_input,
sample_label,
order,
vis_type,
reward_type,
with_label,
label_num=label_num)
else:
scores = evaluate_tool.evaluate(sample_input,
sample_label,
order,
vis_type,
reward_type,
with_label,
label_num=label_num)
# if reward_type == 'parg_pcc':
# scores = abs(scores)
# scores = -scores
return scores
def __init__(self):
self._classifier = AdaBoostClassifier(n_estimators=1000, learning_rate=0.5) # Best classifier
self._database = tools.load_database()
self._X, self._Y = tools.prepare_database(self._database)
self._vocabulary, self._vocabulary_vectors = tools.create_bag_of_words(self._X) # Creates Bag of Words model
self._features_train, self._features_test, self._labels_train, self._labels_test = tools.split_dataset(self._vocabulary_vectors, self._Y)
self._classifier.fit(self._features_train, self._labels_train)
self._scores = tools.evaluate(self._labels_test, self._classifier.predict(self._features_test))
def train(self, max_depth=3):
for i in range(self.T):
pred_y = np.array([]) # k*m
# Train weak learner using distribution D_t
for j in range(self.k):
self.h_t = self.model(max_depth=max_depth, presort=True)
self.h_t.fit(self.X,
self.y[j * self.m:(j + 1) * self.m],
sample_weight=self.D_t[j * self.m:(j + 1) *
self.m])
# Get weak hypothesis h_t
self.h.append(self.h_t)
# Choose alpha_t
pred_y = np.append(pred_y, self.h_t.predict(self.X))
r_t = np.dot(self.D_t, np.multiply(self.y, pred_y))
if abs(r_t - 1) < 0.00000001:
self.alpha_t = 0.5 * log(
(1 + r_t + 0.000001) / (1 - r_t + 0.000001))
else:
self.alpha_t = 0.5 * log((1 + r_t) / (1 - r_t))
self.alphas = np.append(self.alphas, self.alpha_t)
# Update
self.D_t = np.multiply(
self.D_t,
list(map(exp, -self.alpha_t * np.multiply(self.y, pred_y))))
self.D_t /= np.sum(self.D_t)
# self.D = np.append(self.D, self.D_t)
ret_index = self.predict(self.test_X, i + 1)
# for i in range(len(X_test)):
# print(ret_index[i])
# print(y_test[i])
scores = one_error(ret_index, self.test_y)
y_train = []
at_n = 3
for j in range(len(ret_index)):
tmp = [0] * self.k
for ll in ret_index[j]:
if ret_index[j].index(ll) < self.k - at_n:
continue
tmp[self.class_list.index(ll)] = 1
ret_index[j] = tmp
tmp = [0] * self.k
for ll in self.test_y[j]:
tmp[self.class_list.index(ll)] = 1
y_train.append(tmp)
precision, recall, error = evaluate(np.array(ret_index),
np.array(y_train))
print(i, precision, recall, error, scores)
def validate(beam_searcher, dataset, logger=None):
# generating captions
all_candidates = []
for i in xrange(dataset.n_image):
data = dataset.iterate_batch() # data: id, img, scene...
sent = beam_searcher.generate(data[1:])
cap = u' '.join([dataset.vocab[word] for word in sent])
# print data[0], cap
all_candidates.append({u'image_id': data[0], 'caption': cap})
res_file = '{:d}_tmp.json'.format(np.random.randint(0, 10000, 1)[0])
json.dump(all_candidates, open(res_file, 'w'))
gt_file = osp.join(dataset.data_dir, 'captions_'+dataset.data_split+'.json')
scores = evaluate(gt_file, res_file, logger)
os.system('rm -rf %s' % res_file)
return scores
def validate(beam_searcher, dataset, logger=None):
# generating captions
all_candidates = []
for i in xrange(dataset.n_image):
data = dataset.iterate_batch() # data: id, img, scene...
sent = beam_searcher.generate(data[1:])
cap = u' '.join([dataset.vocab[word] for word in sent])
# print data[0], cap
all_candidates.append({u'image_id': data[0], 'caption': cap})
res_file = '{:d}_tmp.json'.format(np.random.randint(0, 10000, 1)[0])
json.dump(all_candidates, open(res_file, 'w'))
gt_file = osp.join(dataset.data_dir, 'captions_'+dataset.data_split+'.json')
scores = evaluate(gt_file, res_file, logger)
os.system('rm -rf %s' % res_file)
return scores
def validate(beam_searcher, dataset, logger=None, res_file=None):
if logger is None:
logger = Logger(None)
# generating captions
all_candidates = []
for i in xrange(dataset.n_image):
data = dataset.iterate_batch() # data: id, img, scene...
sent = beam_searcher.generate(data[1:])
cap = ' '.join([dataset.vocab[word] for word in sent])
print '[{}], id={}, \t\t {}'.format(i, data[0], cap)
all_candidates.append({'image_id': data[0], 'caption': cap})
if res_file is None:
res_file = 'tmp.json'
json.dump(all_candidates, open(res_file, 'w'))
gt_file = osp.join(dataset.data_dir, 'captions_'+dataset.data_split+'.json')
scores = evaluate(gt_file, res_file, logger)
if res_file == 'tmp.json':
os.system('rm -rf %s' % res_file)
return scores
def main(args):
print('\nPreparing {} data'.format(args.dataset))
if args.dataset == 'mnist':
(X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_mnist()
elif args.dataset == 'cifar10':
(X_train, y_train), (X_test, y_test), (X_valid,
y_valid) = load_cifar10()
elif args.dataset == 'cifar100':
(X_train, y_train), (X_test, y_test), (X_valid,
y_valid) = load_cifar100()
print('\nConstruction graph')
if args.model == 'cnn_1':
env = cnn_1(args)
elif args.model == 'cnn_2':
env = cnn_2(args)
elif args.model == 'vgg16':
env = vgg16(args)
elif args.model == 'vgg19':
env = vgg19(args)
print('\nInitializing graph')
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
print('\nLoading saved model')
name = '{0}_{1}'.format(args.model, args.dataset)
env.saver.restore(sess, 'models/{0}/{1}'.format(name, name))
print('\nEvaluating on clean data')
evaluate(sess, env, X_test, y_test)
print('\nExcluding misclassification samples')
# mnist 1000 samples -> 0:1010
# cifar10 1000 samples -> 0:
(X_test, y_test) = exclude_miss(sess, env, X_test, y_test, 0, 12)
evaluate(sess, env, X_test, y_test)
print('\nGenerating adversarial data')
X_adv = make_adv(args, sess, env, X_test, y_test)
print('\nEvaluating on adversarial data')
evaluate(sess, env, X_adv, y_test)
print('\nResults')
img_raw = cv2.imread(IMG_PATH, 1)
img_noisy = Add_Guassian_Noise(img_raw,sigma)
img_H,img_W = BM3D(img_noisy,color_mode,
kHard = k_H , NHard = N_H,nHard = n_H , pHard = p_H,threshold_match_H = threshold_match_H,sigma_H = sigma,
control_p_H = control_p_H , Hard_threshold = Hard_threshold , Is_weight_usesd_H = Is_weight_usesd,
kEst = k_W,nEst = n_W,NEst = N_W , pEst = p_W,threshold_match_W = threshold_match_W,sigma_W = sigma,
control_p_W = control_p_W , Is_weight_usesd_W = Is_weight_usesd ,
mode_H = mode_H , mode_W = mode_W , Is_kaiser = Is_kaiser)
if color_mode > 0:
img_raw = cv2.cvtColor(img_raw, cv2.COLOR_RGB2YUV)
img_W = (np.clip(img_W, 0, 255)).astype(np.uint8)
Psnr_W_Y = evaluate(img_raw[:, :, 0], img_W[:, :, 0])
img_W = cv2.cvtColor(img_W, cv2.COLOR_YUV2RGB)
if Is_weight_usesd > 0:
img_W_name = '.\\output\\usesd\\' + IMG_PATH[:-4] + '_' + \
str(sigma) + '_W_Y' + '%.4f' % Psnr_W_Y + '_useSD.jpg'
cv2.imwrite(img_W_name, img_W)
else:
img_W_name = '.\\output\\unusesd\\' + IMG_PATH[:-4] + '_' + \
str(sigma) + '_W_Y' + '%.4f' % Psnr_W_Y + '.jpg'
cv2.imwrite(img_W_name, img_W)
else:
img_raw = cv2.cvtColor(img_raw, cv2.COLOR_RGB2GRAY)
img_H = (np.clip(img_H, 0, 255)).astype(np.uint8)
def train(self, max_depth=3):
for i in range(self.T):
pred_y = np.array([]) # k*m
# Train weak learner using distribution D_t
for j in range(self.k):
self.h_t = self.model(max_depth=max_depth, presort=True)
self.h_t.fit(self.X,
self.y[j * self.m:(j + 1) * self.m],
sample_weight=np.sum(self.D_t, axis=1)[:, j])
# Get weak hypothesis h_t
self.h.append(self.h_t)
# Choose alpha_t
pred_y = np.append(pred_y, self.h_t.predict(self.X))
tmp_sum = 0
for (x_i, l0, l1) in self.pairs:
tmp_sum += self.D_t[x_i][l0][l1] * (pred_y[l1 * self.m + x_i] -
pred_y[l0 * self.m + x_i])
# for i in range(self.m):
# for l0 in range(self.k):
# for l1 in range(self.k):
# if abs(self.D_t[i][l0][l1]) < 0.0000001:
# continue
# tmp_sum += self.D_t[i][l0][l1]*(pred_y[i*self.k+l1]-pred_y[i*self.k+l0])
r_t = tmp_sum * 0.5
if abs(r_t - 1) < 0.00000001:
self.alpha_t = 0.5 * log(
(1 + r_t + 0.000001) / (1 - r_t + 0.000001))
else:
self.alpha_t = 0.5 * log((1 + r_t) / (1 - r_t))
self.alphas = np.append(self.alphas, self.alpha_t)
# Update
for (x_i, l0, l1) in self.pairs:
self.D_t[x_i][l0][l1] = self.D_t[x_i][l0][l1] * exp(
0.5 * self.alpha_t *
(pred_y[l0 * self.m + x_i] - pred_y[l1 * self.m + x_i]))
self.D_t /= np.sum(self.D_t)
# self.D = np.append(self.D, self.D_t)
ret_index, pred = self.predict(self.test_X, i + 1)
# for i in range(len(X_test)):
# print(ret_index[i])
# print(y_test[i])
scores = one_error(ret_index, self.test_y)
y_train = []
at_n = 3
for j in range(len(ret_index)):
tmp = [0] * self.k
for ll in ret_index[j]:
if ret_index[j].index(ll) < self.k - at_n:
continue
tmp[self.class_list.index(ll)] = 1
ret_index[j] = tmp
tmp = [0] * self.k
for ll in self.test_y[j]:
tmp[self.class_list.index(ll)] = 1
y_train.append(tmp)
precision, recall, error = evaluate(np.array(ret_index),
np.array(y_train))
print(i, precision, recall, error, scores)
def render(encoder_input, encoder_label, dim_indices, save_path, vis_type,
reward_type, with_label, label_num):
"""Plots"""
batch_size = encoder_input.shape[0]
data_num = encoder_input.shape[1]
dim_num = encoder_input.shape[2]
# batch_size x dim_num
idx = dim_indices.unsqueeze(1).repeat(1, data_num, 1)
# batch_size x data_num x dim_num
sample_input = torch.gather(encoder_input.data, 2, idx)
sample_label = torch.gather(encoder_label.data, 2, idx)
for batch_index in range(batch_size):
dpi = 400
# if batch_index >= 10:
# if batch_index not in [6, 56, 62, 77] or batch_index > 10:
if batch_index not in [6]:
continue
data = sample_input[batch_index:batch_index + 1, :, :]
label = sample_label[batch_index:batch_index + 1, :, :]
order = dim_indices[batch_index]
origin_data = encoder_input.data[batch_index:batch_index + 1, :, :]
origin_label = encoder_label.data[batch_index:batch_index + 1, :, :]
origin_order = [i for i in range(dim_num)]
if True:
scores = tools.evaluate(data,
label,
order,
vis_type,
reward_type,
with_label,
label_num=label_num)
origin_scores = tools.evaluate(origin_data,
origin_label,
origin_order,
vis_type,
reward_type,
with_label,
label_num=label_num)
data = data.cpu().numpy()[0]
label = label.cpu().numpy()[0, :, 0]
order = order.cpu().numpy()
origin_data = origin_data.cpu().numpy()[0]
origin_label = origin_label.cpu().numpy()[0, :, 0]
with_category = False
if vis_type == 'star' or vis_type == 'radviz':
data = np.column_stack((label, data))
origin_data = np.column_stack((origin_label, origin_data))
with_category = True
scores = abs(scores)
origin_scores = abs(origin_scores)
if vis_type == 'star':
# TODO draw image
tools.draw(
data,
order,
vis_type,
reward_type,
save_title="%.3f" % (scores),
# save_title="CLASS DIST: %.3f\nSIL: %.3f" % (mer, sil),
# save_name=save_path[:-8] + '-%d' % (batch_index), with_category=with_category,
save_name=save_path[:-8] + '-%d_%.3f' % (batch_index, scores),
with_category=with_category,
dpi=dpi,
label_num=label_num)
tools.draw(
origin_data,
origin_order,
vis_type,
reward_type,
save_title="%.3f" % (origin_scores),
# save_title="CLASS DIST: %.3f\nSIL: %.3f" % (mer_o, sil_o),
# save_name=save_path[:-8] + '-%d-o' % (batch_index), with_category=with_category,
save_name=save_path[:-8] + '-%d-%.3f-o' %
(batch_index, origin_scores),
with_category=with_category,
dpi=dpi,
label_num=label_num)
# print(origin_scores)
# print(scores)
# np.savetxt(save_path[:-8] + '-%.3f_%.3f.txt' % (origin_scores, scores), data[0] )
else:
# TODO draw image
tools.draw(
data,
order,
vis_type,
reward_type,
# save_title="Score: %.3f\n" % (scores),
save_title='',
save_name=save_path[:-8] + '-%d_%.3f' % (batch_index, scores),
with_category=with_category,
dpi=dpi,
label_num=label_num)
tools.draw(
origin_data,
origin_order,
vis_type,
reward_type,
# save_title="Score: %.3f\n" % (origin_scores),
save_title='',
save_name=save_path[:-8] + '-%d-o-_%.3f' %
(batch_index, origin_scores),
with_category=with_category,
dpi=dpi,
label_num=label_num)
# print(origin_scores)
# print(scores)
# np.savetxt(save_path[:-8] + '-%.3f_%.3f.txt' % (origin_scores, scores), data[0] )
# if vis_type == 'star':
# sim, mer, sil = tools.evaluate(sample_input, sample_label, order, vis_type, 'sc_all', with_label, label_num=label_num)
# sim_o, mer_o, sil_o = tools.evaluate(encoder_input, encoder_label, origin_order, vis_type, 'sc_all', with_label, label_num=label_num)
# sim = abs(sim)
# mer = abs(mer)
# sil = abs(sil)
# sim_o = abs(sim_o)
# mer_o = abs(mer_o)
# sil_o = abs(sil_o)
# if reward_type == 'sc_sim':
# scores = sim
# origin_scores = sim_o
# elif reward_type == 'sc_mer':
# scores = mer
# origin_scores = mer_o
# elif reward_type == 'sc_sil':
# scores = sil
# origin_scores = sil_o
# else:
# print('=======> Error in render')
# else:
if True:
order = None
origin_order = None
scores = tools.evaluate(sample_input,
sample_label,
order,
vis_type,
reward_type,
with_label,
label_num=label_num)
origin_scores = tools.evaluate(encoder_input,
encoder_label,
origin_order,
vis_type,
reward_type,
with_label,
label_num=label_num)
# if vis_type == 'star':
# np.savetxt(save_path[:-8] + '-sim.txt', sim.cpu().numpy())
# np.savetxt(save_path[:-8] + '-mer.txt', mer.cpu().numpy())
# np.savetxt(save_path[:-8] + '-sil.txt', sil.cpu().numpy())
# np.savetxt(save_path[:-8] + '-sim_o.txt', sim_o.cpu().numpy())
# np.savetxt(save_path[:-8] + '-mer_o.txt', mer_o.cpu().numpy())
# np.savetxt(save_path[:-8] + '-sil_o.txt', sil_o.cpu().numpy())
ids = dim_indices.cpu().numpy().astype('int')
np.savetxt(save_path[:-8] + '-score.txt', scores.cpu().numpy())
np.savetxt(save_path[:-8] + '-score-o.txt', origin_scores.cpu().numpy())
np.savetxt(save_path[:-8] + '-ids.txt', ids)
def run(config):
pl.seed_everything(config.seed)
# overwrite path
OmegaConf.set_struct(config, True)
with open_dict(config):
config.trainer.model.params.backbone.params.pretrained = False
# build logger
logger = build_logger(config)
# logging for wandb or mlflow
if hasattr(logger, "log_hyperparams"):
for k, v in config.trainer.items():
if not k in ("metrics", "inference"):
logger.log_hyperparams(params=v)
logger.log_hyperparams(params=config.dataset)
logger.log_hyperparams(params=config.augmentation)
# build model
model = build_model(config)
# build hooks
hooks = build_hooks(config)
# build lightning module
lightning_module = build_lightning_module(
config,
model=model,
optimizer=None,
scheduler=None,
hooks=hooks,
dataloaders=None,
strong_transform=None,
)
# load best checkpoint
dir_path = config.trainer.callbacks.ModelCheckpoint.dirpath
if isinstance(OmegaConf.to_container(config.dataset.dataset), list):
idx_fold = config.dataset.dataset[0].params.idx_fold
else:
idx_fold = config.dataset.dataset.params.idx_fold
filename = f"fold_{idx_fold}_best.ckpt"
best_model_path = os.path.join(dir_path, filename)
state_dict = torch.load(best_model_path)["state_dict"]
# if using dp, it is necessary to fix state dict keys
if (
hasattr(config.trainer.trainer, "sync_batchnorm")
and config.trainer.trainer.sync_batchnorm
):
state_dict = kvt.utils.fix_dp_model_state_dict(state_dict)
lightning_module.model.load_state_dict(state_dict)
# inference
columns = [f"pred_{i:03}" for i in range(config.trainer.model.params.num_classes)]
outputs = []
for i, (dataloaders, row_ids) in enumerate(build_test_dataloaders(config)):
lightning_module.dataloaders = dataloaders
_, output = evaluate(
lightning_module,
hooks,
config,
mode="test",
return_predictions=True,
tta=config.augmentation.tta,
)
output = pd.DataFrame(output[0], columns=columns)
output["row_id"] = row_ids
outputs.append(output)
outputs = pd.concat(outputs).reset_index(drop=True)
# save predictions dataframe
path = os.path.join(
config.trainer.inference.dirpath,
config.trainer.inference.filename,
)
outputs.to_pickle(path)
# merge labels
labels = pd.read_csv(f"{config.input_dir}/train_soundscape_labels.csv")
labels["birds"] = labels["birds"].apply(lambda x: x.split())
df = labels.merge(outputs)
# target
target = (
df["birds"]
.apply(lambda x: preprocess_target(x, config.competition.target_unique_values))
.values
)
# evaluate
result = {}
pred = df[columns].values[:, :NUM_CLASSES] > 0.5
for func in [f1_score, precision_score, recall_score]:
result[f"train_soundscapes_{func.__name__}_50"] = func(
target, pred, average="samples", zero_division=1
)
pred = df[columns].values[:, :NUM_CLASSES] > 0.25
for func in [f1_score, precision_score, recall_score]:
result[f"train_soundscapes_{func.__name__}_25"] = func(
target, pred, average="samples", zero_division=1
)
print("Result:")
print(result)
# log
if logger is not None:
logger.log_metrics(result)
bs = BeamSearch(models, beam_size=3, num_cadidates=500, max_length=20)
scores = validate(bs, valid_set)
if task == 'rass':
from model.rass import Model
model_list = ['mscoco-rass-nh512-nw512-na512-mb64-V8843/rass.h5.merge']
models = [Model(model_file=osp.join(SAVE_ROOT, m)) for m in model_list]
valid_set = Reader(batch_size=1,
data_split='test',
vocab_freq='freq5',
stage='val',
data_dir=data_dir,
feature_file='features_30res.h5',
topic_type='pred',
topic_file='lda_topics.h5',
caption_switch='off',
head=0,
tail=1000)
bs = BeamSearch(models, beam_size=3, num_cadidates=500, max_length=20)
scores = validate(bs, valid_set)
if task == 'evaluate':
gt_file = osp.join(data_dir, 'captions_test.json')
res_file = 'tmp.json'
scores = evaluate(gt_file, res_file, None)
for s in scores:
print '{:.1f}'.format(100. * s)
net_datas[batch_index,
data_index] = datas[batch_index,
data_index][ids[batch_index]]
net_labels[batch_index,
data_index] = labels[batch_index,
data_index][ids[batch_index]]
net_datas = torch.from_numpy(net_datas)
net_labels = torch.from_numpy(net_labels)
datas = datas.cuda()
labels = labels.cuda()
net_datas = net_datas.cuda()
net_labels = net_labels.cuda()
init_scores = tools.evaluate(datas[:draw_num], labels[:draw_num], None,
vis_type, 'sc_sil', False)
net_scores = tools.evaluate(net_datas[:draw_num], net_labels[:draw_num], None,
vis_type, 'sc_sil', False)
datas = datas.cpu().numpy()
labels = labels.cpu().numpy()[:, :, 0]
net_datas = net_datas.cpu().numpy()
net_labels = net_labels.cpu().numpy()[:, :, 0]
# for batch_index in range(num_samples):
save_dir = os.path.join(
'./img', vis_type, '%d' % dim_num,
reward_type + '-' + data_type + '-' + str(dim_num) + 'd-' + str(data_num) +
'n-' + str(label_num) + 'c-note-' + note)
print(save_dir)
def run(config):
pl.seed_everything(config.seed)
# overwrite path
OmegaConf.set_struct(config, True)
with open_dict(config):
config.trainer.model.params.backbone.params.pretrained = False
# build model
model = build_model(config)
# build hooks
hooks = build_hooks(config)
# build lightning module
lightning_module = build_lightning_module(
config,
model=model,
optimizer=None,
scheduler=None,
hooks=hooks,
dataloaders=None,
strong_transform=None,
)
# load best checkpoint
dir_path = config.trainer.callbacks.ModelCheckpoint.dirpath
if isinstance(OmegaConf.to_container(config.dataset.dataset), list):
idx_fold = config.dataset.dataset[0].params.idx_fold
else:
idx_fold = config.dataset.dataset.params.idx_fold
filename = f"fold_{idx_fold}_best.ckpt"
best_model_path = os.path.join(dir_path, filename)
state_dict = torch.load(best_model_path)["state_dict"]
# if using dp, it is necessary to fix state dict keys
if (hasattr(config.trainer.trainer, "sync_batchnorm")
and config.trainer.trainer.sync_batchnorm):
state_dict = kvt.utils.fix_dp_model_state_dict(state_dict)
lightning_module.model.load_state_dict(state_dict)
# inference
columns = [
f"pred_{i:03}" for i in range(config.trainer.model.params.num_classes)
]
for i, (dataloaders, row_ids) in enumerate(build_test_dataloaders(config)):
lightning_module.dataloaders = dataloaders
_, output = evaluate(
lightning_module,
hooks,
config,
mode="test",
return_predictions=True,
)
output = pd.DataFrame(output[0], columns=columns)
output["row_id"] = row_ids
# save predictions dataframe
path = os.path.join(
config.trainer.inference.dirpath,
f"{i:03d}_" + config.trainer.inference.filename,
)
output.to_pickle(path)
model_list = ['mscoco-ra-nh512-nw512-na512-mb64-V8843/ra.h5.merge']
models = [Model(model_file=osp.join(SAVE_ROOT, m)) for m in model_list]
valid_set = Reader(batch_size=1, data_split='test', vocab_freq='freq5', stage='test',
data_dir=data_dir, feature_file='features_30res.h5',
caption_switch='off', topic_switch='off', head=0, tail=1000)
bs = BeamSearch(models, beam_size=3, num_cadidates=500, max_length=20)
scores = validate(bs, valid_set)
if task == 'rass':
from model.rass import Model
model_list = ['mscoco-rass-nh512-nw512-na512-mb64-V8843/rass.h5.merge']
models = [Model(model_file=osp.join(SAVE_ROOT, m)) for m in model_list]
valid_set = Reader(batch_size=1, data_split='test', vocab_freq='freq5', stage='val',
data_dir=data_dir, feature_file='features_30res.h5', topic_type='pred',
topic_file='lda_topics.h5', caption_switch='off', head=0, tail=1000)
bs = BeamSearch(models, beam_size=3, num_cadidates=500, max_length=20)
scores = validate(bs, valid_set)
if task == 'evaluate':
gt_file = osp.join(data_dir, 'captions_test.json')
res_file = 'tmp.json'
scores = evaluate(gt_file, res_file, None)
for s in scores:
print '{:.1f}'.format(100.*s)
def train(epochs=120,
init_lr=0.001,
weight_decay=1e-8,
model_num=1,
batch_size=64,
train_dir=train_dir,
test_dir=test_dir,
log_dir=log_dir,
):
#divide data
#data_divide(data_dir=data_dir, train_dir=train_dir, test_dir=test_dir)
#load data
print("data loading......\n")
transform = enhance_transform()
transform_std = transform_standard()
trainset = DataClassify(train_dir, transforms=transform)
testset = DataClassify(test_dir, transforms=transform_std)
train_length = len(trainset)
test_length = len(testset)
data_loader_train = t.utils.data.DataLoader(trainset, batch_size, shuffle=True)
data_loader_test = t.utils.data.DataLoader(testset, batch_size, shuffle=False)
print("loading complete\n")
if model_num==0:
exit(0)
elif model_num==1:
net = resnet18()
elif model_num==2:
net = resnet34()
elif model_num==3:
net = resnet50()
elif model_num==4:
net = resnet101()
elif model_num==5:
net = resnet152()
cost = t.nn.CrossEntropyLoss()
train_loss_list = []
train_accurate_list = []
test_loss_list = []
test_accurate_list = []
for epoch in range(epochs):
print("epoch " + str(epoch+1) + " start training...\n")
net.train()
learning_rate = dloss(train_loss_list, init_lr, lr_coefficient, init_lr)
optimizer = t.optim.Adam(list(net.parameters()), lr=learning_rate, weight_decay=weight_decay)
run_loss, corr = train_once(data_loader_train, net, optimizer, cost)
train_loss_list.append(run_loss/train_length)
train_accurate_list.append(corr/train_length)
print('epoch %d, training loss %.6f, training accuracy %.4f ------\n' %(epoch+1, run_loss/train_length, corr/train_length))
print("epoch " + str(epoch+1) + " finish training\n")
print("-----------------------------------------------\n")
print("epoch " + str(epoch+1) + " start testing...\n")
net.eval()
test_corr = evaluate(net, data_loader_test)
test_accurate_list.append(test_corr/test_length)
print('epoch %d, testing accuracy %.4f ------\n' %(epoch+1, test_corr/test_length))
print("epoch " + str(epoch+1) + " finish testing\n")
print("-----------------------------------------------\n")
curve_draw(train_loss_list, train_accurate_list, test_accurate_list, log_dir)
import argparse
import yaml
import tools
parser = argparse.ArgumentParser()
parser.add_argument('-visualize', action='store_true')
parser.add_argument('-predict', action='store_true')
parser.add_argument('-slice', action='store_true')
parser.add_argument('-evaluate', action='store_true')
args = parser.parse_args()
with open('./configs.yaml', 'r') as stream:
try:
configs = yaml.safe_load(stream)
except yaml.YAMLError as exc:
print(exc)
if args.visualize:
tools.visualize(configs)
elif args.predict:
tools.predict(configs)
elif args.slice:
tools.slice_vids(configs)
elif args.evaluate:
tools.evaluate(configs)
else:
raise ValueError(
'Did not set flag: -visualize, -predict, -slice, -evaluate')