def main():
args = get_args()
config = process_config(args)
print(config)
if config.get('seed') is not None:
random.seed(config.seed)
torch.manual_seed(config.seed)
np.random.seed(config.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(config.seed)
dataset = get_dataset(config.dataset_name).shuffle()
run_model(Net, dataset, config=config)
def main():
# Get arguments parsed
args = get_args()
# Setup for logging
output_dir = 'output/{}'.format(get_datetime_str())
create_dir(output_dir) # Create directory to save log files and outputs
LogHelper.setup(log_path='{}/training.log'.format(output_dir),
level='INFO')
_logger = logging.getLogger(__name__)
_logger.info("Finished setting up the logger.")
# Save configs
save_yaml_config(vars(args), path='{}/config.yaml'.format(output_dir))
# Reproducibility
set_seed(args.seed)
# Load dataset
dataset = SyntheticDataset(args.n, args.d, args.graph_type, args.degree,
args.noise_type, args.B_scale, args.seed)
_logger.info("Finished loading the dataset.")
# Load B_init for initialization
if args.init:
if args.init_path is None:
args.init_path = get_init_path('output/')
B_init = np.load('{}'.format(args.init_path))
_logger.info("Finished loading B_init from {}.".format(args.init_path))
else:
B_init = None
# GOLEM
B_est = golem(dataset.X, args.lambda_1, args.lambda_2,
args.equal_variances, args.num_iter, args.learning_rate,
args.seed, args.checkpoint_iter, output_dir, B_init)
_logger.info("Finished training the model.")
# Post-process estimated solution
B_processed = postprocess(B_est, args.graph_thres)
_logger.info("Finished post-processing the estimated graph.")
# Checkpoint
checkpoint_after_training(output_dir, dataset.X, dataset.B, B_init, B_est,
B_processed, _logger.info)
def main():
args = get_args()
config = process_config(args.config)
# logging to the file and stdout
logger = get_logger(config.log_dir, config.experiment)
# fix random seed to reproduce results
random.seed(config.random_seed)
logger.info('Random seed: {:d}'.format(config.random_seed))
model = Deeplab(config, logger)
# Get train dataloader
target_loader = get_target_train_dataloader(config.datasets.target)
# Get validation dataloader
val_loader = get_target_val_dataloader(config.datasets.target)
if config.mode == 'train':
model.train(target_loader, val_loader)
def step_one_test():
args = get_args()
print(args)
one_quest_test_list = read_data_json("./data/test.json")
print(one_quest_test_list)
#Checkpoint.CHECKPOINT_DIR_NAME = "0120_0030"
Checkpoint.CHECKPOINT_DIR_NAME = args.checkpoint_dir_name
checkpoint_path = os.path.join("./experiment",
Checkpoint.CHECKPOINT_DIR_NAME, "best")
print('-----', args.checkpoint_dir_name, checkpoint_path)
checkpoint = Checkpoint.load(checkpoint_path)
seq2seq = checkpoint.model
if args.cuda_use:
seq2seq = seq2seq.cuda()
data_loader = DataLoader(args)
seq2seq.eval()
evaluator = Evaluator(vocab_dict=data_loader.vocab_dict,
vocab_list=data_loader.vocab_list,
decode_classes_dict=data_loader.decode_classes_dict,
decode_classes_list=data_loader.decode_classes_list,
loss=NLLLoss(),
cuda_use=args.cuda_use)
name = args.run_flag
test_temp_acc, test_ans_acc = evaluator.evaluate(
model=seq2seq,
data_loader=data_loader,
data_list=one_quest_test_list,
template_flag=False, # todo: 这里改成了false
batch_size=64,
evaluate_type=0,
use_rule=False,
mode=args.mode,
post_flag=args.post_flag,
name_save=name)
print(test_temp_acc, test_ans_acc)
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args)
print(config)
except Exception as e:
print("missing or invalid arguments %s" % e)
exit(0)
torch.manual_seed(100)
np.random.seed(100)
# torch.backends.cudnn.deterministic = True # can impact performance
# torch.backends.cudnn.benchmark = False # can impact performance
print("lr = {0}".format(config.hyperparams.learning_rate))
print("decay = {0}".format(config.hyperparams.decay_rate))
if config.target_param is not False: # (0 == False) while (0 is not False)
print("target parameter: {0}".format(config.target_param))
print(config.architecture)
# create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir])
doc_utils.doc_used_config(config)
data = DataGenerator(config)
# create an instance of the model you want
model_wrapper = ModelWrapper(config, data)
# create trainer and pass all the previous components to it
trainer = Trainer(model_wrapper, data, config)
# here you train your model
trainer.train()
# test model, restore best model
test_dists, test_loss = trainer.test(load_best_model=True)
"Dev: time: %.2fs, speed: %.2fst/s; acc: %.4f, p: %.4f, r: %.4f, f: %.4f"
% (dev_cost, speed, acc, p, r, f))
if current_score > best_dev:
print("Exceed previous best f score:", best_dev)
if not os.path.exists(args.param_stored_directory +
args.dataset_name + "_param"):
os.makedirs(args.param_stored_directory + args.dataset_name +
"_param")
model_name = "{}epoch_{}_f1_{}.model".format(
args.param_stored_directory + args.dataset_name + "_param/",
idx, current_score)
torch.save(model.state_dict(), model_name)
best_dev = current_score
gc.collect()
if __name__ == '__main__':
args, unparsed = get_args()
for arg in vars(args):
print(arg, ":", getattr(args, arg))
# os.environ["CUDA_VISIBLE_DEVICES"] = str(args.visible_gpu)
seed = args.random_seed
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
np.random.seed(seed)
random.seed(seed)
torch.backends.cudnn.deterministic = False # True
data = data_initialization(args)
model = BLSTM_GAT_CRF(data, args)
train(data, model, args)
return retrievers, rankers, reformulators, formatters
def set_width(max_width):
st.markdown(
f"""
<style>
.reportview-container .main .block-container{{
max-width: {max_width}px;
padding-top: {5}rem;
padding-right: {5}rem;
padding-left: {5}rem;
padding-bottom: {5}rem;
}}
.reportview-container .main {{
color: BLACK;
background-color: WHITE;
}}
</style>
""",
unsafe_allow_html=True,
)
if __name__ == '__main__':
args = get_args()
retriever_models_dict, ranker_models_dict, reformulator_dict, formatter_dict = load_models_on_start(
args)
main(args, retriever_models_dict, ranker_models_dict, reformulator_dict,
formatter_dict)
def main():
# 获取配置文件路径
# 运行：python main.py -c configs/ed_config.json #for softmax
# python main.py -c configs/ed_siamese_config.json #for siamese
# Or: python main.py -c configs/who_config.json #for WHO
# 可视化: tensorboard --logdir=experiments/Compare/logs
try:
args = get_args()
config = process_config(args.config)
except:
print("missing or invalid arguments")
exit(0)
create_dirs([])
No, max_score = -1, 0
save_tag = config.exp_name
# 重复10次实验
for i in range(config.repeat):
# (1)载入数据
print('Create the data generator.')
train_dataset = MRIData(config, train=True)
test_dataset = MRIData(config, train=False)
# printData(test_dataset, type='normal')
'''
data_num
(5L, 5L, 32L, 32L) 0.0
(5L, 5L, 32L, 32L) 2.0
...
(5L, 5L, 32L, 32L) 1.0
(5L, 5L, 32L, 32L) 3.0
...
'''
if config.exp_name == 'siamese' or config.exp_name == 'compare':
# Set up data loaders
# Returns pairs of images and target same/different
# if config.isSelect and False:
# from data_loader.datasets import BalancedBatchSampler
# train_batch_dataset = BalancedBatchSampler(train_dataset, n_classes=config.classes, n_samples=16)
# test_batch_dataset = BalancedBatchSampler(test_dataset, n_classes=config.classes, n_samples=16)
# else:
train_dataset = SiameseMRI(train_dataset)
test_dataset = SiameseMRI(test_dataset)
# printData(test_dataset, type=config.exp_name, only_shape=True)
'''
data_num
(5L, 5L, 32L, 32L) (5L, 5L, 32L, 32L) 1 [2.0, 2.0]
(5L, 5L, 32L, 32L) (5L, 5L, 32L, 32L) 1 [0.0, 0.0]
...
(5L, 5L, 32L, 32L) (5L, 5L, 32L, 32L) 0 [3.0, 0.0]
(5L, 5L, 32L, 32L) (5L, 5L, 32L, 32L) 0 [1.0, 0.0]
...
'''
elif config.exp_name == 'triplet':
# Set up data loaders
# Returns triplets of images
train_dataset = TripletMRI(train_dataset)
test_dataset = TripletMRI(test_dataset)
# 批数据
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}
# if config.exp_name == 'siamese' and config.isSelect and False:
# train_loader = torch.utils.data.DataLoader(train_dataset, batch_sampler=train_batch_dataset, **kwargs)
# test_loader = torch.utils.data.DataLoader(test_dataset, batch_sampler=test_batch_dataset, **kwargs)
# else:
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config.batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=config.batch_size,
shuffle=False,
**kwargs)
# printData(test_loader, type=config.exp_name, only_shape = False)
'''
for siamese:
data_num/batch_size
(16L, 5L, 5L, 32L, 32L) (16L, 5L, 5L, 32L, 32L) (16L,) [(16L,), (16L,)]
...
(8L, 5L, 5L, 32L, 32L) (8L, 5L, 5L, 32L, 32L) (16L,) [(8L,), (8L,)]
'''
# (2)构建模型
# # Set up the network and training parameters
embedding_net = EmbeddingNet3D(len(config.Fusion),
config.embedding_size)
if config.exp_name == 'softmax':
model = ClassificationNet(embedding_net, n_classes=config.classes)
model.apply(weights_init)
print(model)
if cuda:
model.cuda()
loss_fn = torch.nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-2)
scheduler = lr_scheduler.StepLR(optimizer,
8,
gamma=0.1,
last_epoch=-1)
fit(train_loader, test_loader, model, loss_fn, optimizer, scheduler, config.num_epochs,\
cuda, log_interval = config.log_interval, metrics=[AccuracyMetric()])
elif config.exp_name == 'siamese':
# if config.isSelect and False:
# model = embedding_net
# print(model)
# if cuda:
# model.cuda()
# from models.losses import OnlineContrastiveLoss
# # Strategies for selecting pairs within a minibatch
# from utils.selector import AllPositivePairSelector, HardNegativePairSelector
# loss_fn = OnlineContrastiveLoss(margin, HardNegativePairSelector())
# else:
model = SiameseNet(embedding_net)
model.apply(weights_init)
print(model)
if cuda:
model.cuda()
loss_fn = ContrastiveLoss(config.margin)
optimizer = optim.Adam(model.parameters(), lr=1e-2)
scheduler = lr_scheduler.StepLR(optimizer,
8,
gamma=0.1,
last_epoch=-1)
fit(train_loader, test_loader, model, loss_fn, optimizer, scheduler, config.num_epochs,\
cuda, log_interval = config.log_interval, obj_label=True)
elif config.exp_name == 'triplet':
model = TripletNet(embedding_net)
model.apply(weights_init)
print(model)
if cuda:
model.cuda()
loss_fn = TripletLoss(config.margin)
optimizer = optim.Adam(model.parameters(), lr=1e-2)
scheduler = lr_scheduler.StepLR(optimizer,
8,
gamma=0.1,
last_epoch=-1)
fit(train_loader, test_loader, model, loss_fn, optimizer, scheduler, config.num_epochs,\
cuda, log_interval = config.log_interval, obj_label=True)
elif config.exp_name == 'compare':
model = CompareNet(embedding_net, 2 * config.embedding_size)
model.apply(weights_init)
print(model)
if cuda:
model.cuda()
if cuda:
model.cuda()
loss_fn = torch.nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-2)
scheduler = lr_scheduler.StepLR(optimizer,
8,
gamma=0.1,
last_epoch=-1)
fit(train_loader, test_loader, model, loss_fn, optimizer, scheduler, config.num_epochs,\
cuda, log_interval = config.log_interval, metrics=[AccuracyMetric()], obj_label=True)
# 读取未扩容未采样的数据
# Set up data loaders
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {}
config.isSample = False #不再采样
config.isAug = False #不扩容
train_dataset = MRIData(config, train=True)
test_dataset = MRIData(config, train=False)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=1000,
shuffle=False,
**kwargs)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=1000,
shuffle=False,
**kwargs)
# 特征可视化
train_embeddings_cl, train_labels_cl = extract_embeddings(
train_loader, model)
plot_embeddings(train_embeddings_cl,
train_labels_cl,
save_tag='train',
n_classes=config.classes)
val_embeddings_cl, val_labels_cl = extract_embeddings(
test_loader, model)
plot_embeddings(val_embeddings_cl,
val_labels_cl,
save_tag='test',
n_classes=config.classes)
# 保存整个模型
torch.save(model, 'models/model.pkl')
# (3)评估siamese模型
model = torch.load('models/model.pkl') #加载模型
if config.exp_name == 'compare':
siamese_eval.score(config, train_loader, test_loader, model, cuda)
else:
siamese_eval.eval(config, train_loader, test_loader, model, cuda)
def main():
args = get_args()
config = process_config(args)
print(config)
if config.get('seed') is not None:
random.seed(config.seed)
torch.manual_seed(config.seed)
np.random.seed(config.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(config.seed)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
### automatic dataloading and splitting
sys.stdin = In()
dataset = PygGraphPropPredDataset(name=config.dataset_name)
if config.feature == 'full':
pass
elif config.feature == 'simple':
print('using simple feature')
# only retain the top two node/edge features
dataset.data.x = dataset.data.x[:, :2]
dataset.data.edge_attr = dataset.data.edge_attr[:, :2]
split_idx = dataset.get_idx_split()
### automatic evaluator. takes dataset name as input
evaluator = Evaluator(config.dataset_name)
train_loader = DataLoader(dataset[split_idx["train"]],
batch_size=config.hyperparams.batch_size,
shuffle=True,
num_workers=config.num_workers)
valid_loader = DataLoader(dataset[split_idx["valid"]],
batch_size=config.hyperparams.batch_size,
shuffle=False,
num_workers=config.num_workers)
test_loader = DataLoader(dataset[split_idx["test"]],
batch_size=config.hyperparams.batch_size,
shuffle=False,
num_workers=config.num_workers)
model = Net(config.architecture, num_tasks=dataset.num_tasks).to(device)
optimizer = optim.Adam(model.parameters(),
lr=config.hyperparams.learning_rate)
scheduler = torch.optim.lr_scheduler.StepLR(
optimizer,
step_size=config.hyperparams.step_size,
gamma=config.hyperparams.decay_rate)
valid_curve = []
test_curve = []
train_curve = []
trainL_curve = []
writer = SummaryWriter(config.directory)
ts_fk_algo_hp = str(config.time_stamp) + '_' \
+ str(config.commit_id[0:7]) + '_' \
+ str(config.architecture.methods) + '_' \
+ str(config.architecture.pooling) + '_' \
+ str(config.architecture.JK) + '_' \
+ str(config.architecture.layers) + '_' \
+ str(config.architecture.hidden) + '_' \
+ str(config.architecture.variants.BN) + '_' \
+ str(config.architecture.dropout) + '_' \
+ str(config.hyperparams.learning_rate) + '_' \
+ str(config.hyperparams.step_size) + '_' \
+ str(config.hyperparams.decay_rate) + '_' \
+ 'B' + str(config.hyperparams.batch_size) + '_' \
+ 'S' + str(config.seed if config.get('seed') is not None else "na") + '_' \
+ 'W' + str(config.num_workers if config.get('num_workers') is not None else "na")
for epoch in range(1, config.hyperparams.epochs + 1):
print("Epoch {} training...".format(epoch))
train_loss = train(model, device, train_loader, optimizer,
dataset.task_type)
scheduler.step()
print('Evaluating...')
train_perf = eval(model, device, train_loader, evaluator)
valid_perf = eval(model, device, valid_loader, evaluator)
test_perf = eval(model, device, test_loader, evaluator)
print('Train:', train_perf[dataset.eval_metric], 'Validation:',
valid_perf[dataset.eval_metric], 'Test:',
test_perf[dataset.eval_metric], 'Train loss:', train_loss)
train_curve.append(train_perf[dataset.eval_metric])
valid_curve.append(valid_perf[dataset.eval_metric])
test_curve.append(test_perf[dataset.eval_metric])
trainL_curve.append(train_loss)
writer.add_scalars(
config.dataset_name,
{ts_fk_algo_hp + '/traP': train_perf[dataset.eval_metric]}, epoch)
writer.add_scalars(
config.dataset_name,
{ts_fk_algo_hp + '/valP': valid_perf[dataset.eval_metric]}, epoch)
writer.add_scalars(
config.dataset_name,
{ts_fk_algo_hp + '/tstP': test_perf[dataset.eval_metric]}, epoch)
writer.add_scalars(config.dataset_name,
{ts_fk_algo_hp + '/traL': train_loss}, epoch)
writer.close()
if 'classification' in dataset.task_type:
best_val_epoch = np.argmax(np.array(valid_curve))
best_train = max(train_curve)
else:
best_val_epoch = np.argmin(np.array(valid_curve))
best_train = min(train_curve)
print(
'Finished test: {}, Validation: {}, epoch: {}, best train: {}, best loss: {}'
.format(test_curve[best_val_epoch], valid_curve[best_val_epoch],
best_val_epoch, best_train, min(trainL_curve)))
def main():
args = get_args()
config = process_config(args)
print(config)
if config.get('seed') is not None:
torch.manual_seed(config.seed)
np.random.seed(config.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(config.seed)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
### automatic dataloading and splitting
dataset = PygGraphPropPredDataset(name=config.dataset_name)
seq_len_list = np.array([len(seq) for seq in dataset.data.y])
print('Target seqence less or equal to {} is {}%.'.format(config.max_seq_len, np.sum(seq_len_list <= config.max_seq_len) / len(seq_len_list)))
split_idx = dataset.get_idx_split()
# print(split_idx['train'])
# print(split_idx['valid'])
# print(split_idx['test'])
# train_method_name = [' '.join(dataset.data.y[i]) for i in split_idx['train']]
# valid_method_name = [' '.join(dataset.data.y[i]) for i in split_idx['valid']]
# test_method_name = [' '.join(dataset.data.y[i]) for i in split_idx['test']]
# print('#train')
# print(len(train_method_name))
# print('#valid')
# print(len(valid_method_name))
# print('#test')
# print(len(test_method_name))
# train_method_name_set = set(train_method_name)
# valid_method_name_set = set(valid_method_name)
# test_method_name_set = set(test_method_name)
# # unique method name
# print('#unique train')
# print(len(train_method_name_set))
# print('#unique valid')
# print(len(valid_method_name_set))
# print('#unique test')
# print(len(test_method_name_set))
# # unique valid/test method name
# print('#valid unseen during training')
# print(len(valid_method_name_set - train_method_name_set))
# print('#test unseen during training')
# print(len(test_method_name_set - train_method_name_set))
### building vocabulary for sequence predition. Only use training data.
vocab2idx, idx2vocab = get_vocab_mapping([dataset.data.y[i] for i in split_idx['train']], config.num_vocab)
# test encoder and decoder
# for data in dataset:
# # PyG >= 1.5.0
# print(data.y)
#
# # PyG 1.4.3
# # print(data.y[0])
# data = encode_y_to_arr(data, vocab2idx, config.max_seq_len)
# print(data.y_arr[0])
# decoded_seq = decode_arr_to_seq(data.y_arr[0], idx2vocab)
# print(decoded_seq)
# print('')
## test augment_edge
# data = dataset[2]
# print(data)
# data_augmented = augment_edge(data)
# print(data_augmented)
### set the transform function
# augment_edge: add next-token edge as well as inverse edges. add edge attributes.
# encode_y_to_arr: add y_arr to PyG data object, indicating the array representation of a sequence.
dataset.transform = transforms.Compose([augment_edge, lambda data: encode_y_to_arr(data, vocab2idx, config.max_seq_len)])
### automatic evaluator. takes dataset name as input
evaluator = Evaluator(config.dataset_name)
train_loader = DataLoader(dataset[split_idx["train"]], batch_size=config.hyperparams.batch_size, shuffle=True, num_workers=config.num_workers)
valid_loader = DataLoader(dataset[split_idx["valid"]], batch_size=config.hyperparams.batch_size, shuffle=False, num_workers=config.num_workers)
test_loader = DataLoader(dataset[split_idx["test"]], batch_size=config.hyperparams.batch_size, shuffle=False, num_workers=config.num_workers)
nodetypes_mapping = pd.read_csv(os.path.join(dataset.root, 'mapping', 'typeidx2type.csv.gz'))
nodeattributes_mapping = pd.read_csv(os.path.join(dataset.root, 'mapping', 'attridx2attr.csv.gz'))
### Encoding node features into emb_dim vectors.
### The following three node features are used.
# 1. node type
# 2. node attribute
# 3. node depth
node_encoder = ASTNodeEncoder(config.architecture.hidden, num_nodetypes=len(nodetypes_mapping['type']), num_nodeattributes=len(nodeattributes_mapping['attr']), max_depth=20)
model = Net(config.architecture,
num_vocab=len(vocab2idx),
max_seq_len=config.max_seq_len,
node_encoder=node_encoder).to(device)
# optimizer = optim.Adam(model.parameters(), lr=0.001)
optimizer = optim.Adam(model.parameters(), lr=config.hyperparams.learning_rate)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=config.hyperparams.step_size,
gamma=config.hyperparams.decay_rate)
valid_curve = []
test_curve = []
train_curve = []
trainL_curve = []
writer = SummaryWriter(config.directory)
ts_fk_algo_hp = str(config.time_stamp) + '_' \
+ str(config.commit_id[0:7]) + '_' \
+ str(config.architecture.nonlinear_conv) + '_' \
+ str(config.architecture.variants.fea_activation) + '_' \
+ str(config.architecture.pooling) + '_' \
+ str(config.architecture.JK) + '_' \
+ str(config.architecture.layers) + '_' \
+ str(config.architecture.hidden) + '_' \
+ str(config.architecture.variants.BN) + '_' \
+ str(config.architecture.dropout) + '_' \
+ str(config.hyperparams.learning_rate) + '_' \
+ str(config.hyperparams.step_size) + '_' \
+ str(config.hyperparams.decay_rate) + '_' \
+ 'B' + str(config.hyperparams.batch_size) + '_' \
+ 'S' + str(config.seed)
for epoch in range(1, config.hyperparams.epochs + 1):
print("Epoch {} training...".format(epoch))
train_loss = train(model, device, train_loader, optimizer)
scheduler.step()
print('Evaluating...')
train_perf = eval(model, device, train_loader, evaluator, arr_to_seq=lambda arr: decode_arr_to_seq(arr, idx2vocab))
valid_perf = eval(model, device, valid_loader, evaluator, arr_to_seq=lambda arr: decode_arr_to_seq(arr, idx2vocab))
test_perf = eval(model, device, test_loader, evaluator, arr_to_seq=lambda arr: decode_arr_to_seq(arr, idx2vocab))
# print({'Train': train_perf, 'Validation': valid_perf, 'Test': test_perf})
print('Train:', train_perf[dataset.eval_metric],
'Validation:', valid_perf[dataset.eval_metric],
'Test:', test_perf[dataset.eval_metric],
'Train loss:', train_loss)
train_curve.append(train_perf[dataset.eval_metric])
valid_curve.append(valid_perf[dataset.eval_metric])
test_curve.append(test_perf[dataset.eval_metric])
trainL_curve.append(train_loss)
writer.add_scalars(config.dataset_name, {ts_fk_algo_hp + '/traP': train_perf[dataset.eval_metric]}, epoch)
writer.add_scalars(config.dataset_name, {ts_fk_algo_hp + '/valP': valid_perf[dataset.eval_metric]}, epoch)
writer.add_scalars(config.dataset_name, {ts_fk_algo_hp + '/tstP': test_perf[dataset.eval_metric]}, epoch)
writer.add_scalars(config.dataset_name, {ts_fk_algo_hp + '/traL': train_loss}, epoch)
writer.close()
print('F1')
best_val_epoch = np.argmax(np.array(valid_curve))
best_train = max(train_curve)
print('Finished training!')
print('Best validation score: {}'.format(valid_curve[best_val_epoch]))
print('Test score: {}'.format(test_curve[best_val_epoch]))
print('Finished test: {}, Validation: {}, Train: {}, epoch: {}, best train: {}, best loss: {}'
.format(test_curve[best_val_epoch], valid_curve[best_val_epoch], train_curve[best_val_epoch],
best_val_epoch, best_train, min(trainL_curve)))
from __future__ import print_function
import tensorflow as tf
import numpy as np
import time, os, csv, random, pdb
from pylab import *
from utils.accumulator import Accumulator
from utils.train import *
from utils.mnist import mnist_subset
from utils.config import get_args, setup
args = get_args(sys.argv[1:])
savedir = setup(args)
# To protect Human Error!
if args.model == 'dpse':
from model.vsepro.vsepro_nway_kl import combine
else:
print("select proper args.model!")
raise NotImplementedError()
xtr, xtrte, xte, nxtr, nxtrte, nxte = mnist_subset([100] * 5)
# set-embedding placeholder x 10
x_emb = [
tf.placeholder(tf.float32, [None, 784], name='x_emb_%d' % k)
for k in range(args.way)
]
# query placeholder x 10
x_qry = [
output = [m(x) for m in self.children()]
if scores is not None:
scores = scores[:, self.body_parts]
scores = torch.transpose(scores, 1, 0).long() - 1
loss = torch.stack([F.cross_entropy(out, tar) for out, tar in zip(output, scores)]).sum()
else:
loss = 0
risks = torch.stack([torch.max(out, dim=1)[1] + 1 for out in output]).transpose(1, 0).detach()
return risks, loss
if __name__ == '__main__':
from dataloaders import make_dataloaders
from utils.config import get_args
from utils.misc import get_available_device
args, _ = get_args()
args.device = get_available_device(0)
_, _, _, test_loader, num_classes = make_dataloaders(args)
data = torch.randn((args.test_batch_size, 1024))
# targets = torch.FloatTensor([[2, 3, 4], [2, 3, 4]])
_, scores, targets = test_loader.get_batch()
del test_loader
model = Classifiers(in_dim=1024, k=num_classes, body_parts=args.body_parts)
output, loss = model(data, targets=scores)
print('done')