def main():
model = ConvModel(args=None, vocabx=None, vocaby=None)
model_path = sys.argv[1]
model.load_model(model_path)
print model.args
run_demo(model)
def evaluation(cfg):
logger = logging.getLogger("JigsawPuzzle")
if torch.cuda.is_available():
device = "cuda"
torch.backends.cudnn.benchmark = True
else:
device = "cpu"
if cfg.dataset == "MNIST":
in_c = 1
else:
in_c = 3
model = ConvModel(in_c, cfg.pieces, cfg.image_size, cfg.hid_c, cfg.stride, cfg.kernel_size)
model.load_state_dict(torch.load(os.path.join(cfg.out_dir, "model.pth")))
model = model.to(device)
eval_data = build_dataset(cfg, split="test")
loader = DataLoader(eval_data, cfg.batch_size, shuffle=False, num_workers=cfg.num_workers, drop_last=False)
with torch.no_grad():
l1_diffs = []
l2_diffs = []
prop_wrongs = []
prop_any_wrongs = []
kendall_taus = []
logger.info("start evaluation")
for data in loader:
inputs, _ = data
pieces, random_pieces, perm_index = batch_tch_divide_image(inputs, cfg.pieces)
pieces, random_pieces = pieces.to(device), random_pieces.to(device)
log_alpha = model(random_pieces)
gumbel_matching_mat = gumbel_sinkhorn_ops.gumbel_matching(log_alpha, noise=False)
hard_sorted_pieces = gumbel_sinkhorn_ops.inverse_permutation_for_image(random_pieces, gumbel_matching_mat)
est_perm_index = gumbel_matching_mat.max(1)[1].float()
hard_l1_diff = (pieces - hard_sorted_pieces).abs().mean((2,3,4)) # (batchsize, num_pieces)
hard_l2_diff = (pieces - hard_sorted_pieces).pow(2).mean((2,3,4))
sign_l1_diff = hard_l1_diff.sign()
prop_wrong = sign_l1_diff.mean(1)
prop_any_wrong = sign_l1_diff.sum(1).sign()
np_perm_index = perm_index.detach().numpy()
np_est_perm_index = est_perm_index.to("cpu").numpy()
kendall_tau = metric.kendall_tau(np_est_perm_index, np_perm_index)
l1_diffs.append(hard_l1_diff); l2_diffs.append(hard_l2_diff)
prop_wrongs.append(prop_wrong); prop_any_wrongs.append(prop_any_wrong)
kendall_taus.append(kendall_tau)
mean_l1_diff = torch.cat(l1_diffs).mean()
mean_l2_diff = torch.cat(l2_diffs).mean()
mean_prop_wrong = torch.cat(prop_wrongs).mean()
mean_prop_any_wrong = torch.cat(prop_any_wrongs).mean()
mean_kendall_tau = np.concatenate(kendall_taus).mean()
logger.info("\nmean l1 diff : %f\n mean l2 diff : %f\n mean prop wrong : %f\n mean prop any wrong : %f\n mean kendall tau : %f",
mean_l1_diff, mean_l2_diff, mean_prop_wrong, mean_prop_any_wrong, mean_kendall_tau
)
def create_predictor(dataset, model_config, model_params, batch_size):
x = T.matrix('x')
y = T.imatrix('y')
drop = T.iscalar('drop')
index = T.lscalar()
model = ConvModel(model_config, verbose=True)
model.build(x, drop, batch_size, init_params=model_params)
return create_output_func(dataset, x, y, drop, [index], model.get_output_layer(), batch_size)
def create_simple_predictor(model_config, model_params):
#TODO: Does this single predictor even work?
data = T.matrix('data')
x = T.matrix('x')
drop = T.iscalar('drop')
batch_size = 1
model = ConvModel(model_config, verbose=True)
model.build(x, drop, batch_size, init_params=model_params)
return model.create_predict_function(x, drop, data)
def create_simple_predictor(model_config, model_params):
#TODO: Does this single predictor even work?
data = T.matrix('data')
x = T.matrix('x')
drop = T.iscalar('drop')
batch_size = 1
model = ConvModel(model_config, verbose=True)
model.build(x, drop, batch_size, init_params=model_params)
return model.create_predict_function(x, drop, data)
def create_predictor(dataset, model_config, model_params, batch_size):
x = T.matrix('x')
y = T.imatrix('y')
drop = T.iscalar('drop')
index = T.lscalar()
model = ConvModel(model_config, verbose=True)
model.build(x, drop, batch_size, init_params=model_params)
return create_output_func(dataset, x, y, drop, [index],
model.get_output_layer(), batch_size)
def train(cfg):
logger = logging.getLogger("JigsawPuzzle")
if torch.cuda.is_available():
device = "cuda"
torch.backends.cudnn.benchmark = True
else:
device = "cpu"
if cfg.dataset == "MNIST":
in_c = 1
else:
in_c = 3
train_data = build_dataset(cfg, "train")
model = ConvModel(in_c, cfg.pieces, cfg.image_size, cfg.hid_c, cfg.stride, cfg.kernel_size).to(device)
optimizer = optim.Adam(model.parameters(), cfg.lr, eps=1e-8)
train_loader = DataLoader(train_data, cfg.batch_size, shuffle=True, num_workers=cfg.num_workers, drop_last=True)
logger.info("start training")
for epoch in range(1, cfg.epochs+1):
sum_loss = 0
for i, data in enumerate(train_loader):
inputs, _ = data
pieces, random_pieces, _ = batch_tch_divide_image(inputs, cfg.pieces)
pieces, random_pieces = pieces.to(device), random_pieces.to(device)
log_alpha = model(random_pieces)
gumbel_sinkhorn_mat = [
gumbel_sinkhorn_ops.gumbel_sinkhorn(log_alpha, cfg.tau, cfg.n_sink_iter)
for _ in range(cfg.n_samples)
]
est_ordered_pieces = [
gumbel_sinkhorn_ops.inverse_permutation_for_image(random_pieces, gs_mat)
for gs_mat in gumbel_sinkhorn_mat
]
loss = sum([
torch.nn.functional.mse_loss(X, pieces)
for X in est_ordered_pieces
])
optimizer.zero_grad()
loss.backward()
optimizer.step()
sum_loss += loss.item()
if cfg.display > 0 and ((i+1) % cfg.display) == 0:
logger.info("epoch %i [%i/%i] loss %f", epoch, i+1, len(train_loader), loss.item())
logger.info("epoch %i| mean loss %f", epoch, sum_loss/len(train_loader))
torch.save(model.state_dict(), os.path.join(cfg.out_dir, "model.pth"))
def main():
model = ConvModel(
args = None,
vocabx = None,
vocaby = None
)
model_path = sys.argv[1]
model.load_model(model_path)
print model.args
run_demo(model)
def run_cnn(model_params,
optimization_params,
dataset_path,
dataset_params,
filename_params,
visual_params,
epochs,
verbose=False):
print(filename_params)
if not os.path.exists(filename_params.results):
os.makedirs(filename_params.results)
is_config, config_values = interface.command.get_command("-config")
is_curriculum, curriculum_set = interface.command.get_command(
"-curriculum")
is_batch_run, batch_index = interface.command.get_command("-batch",
default="0")
is_init_params, param_path = interface.command.get_command("-params")
if is_config:
#Assume config is speficially for running bootstrapping batches.
config_arr = eval(config_values)
if len(config_arr) == 2:
loss_function = config_arr[0]
label_noise = float(config_arr[1])
dataset_params.label_noise = label_noise
model_params.loss = loss_function
batch_index = loss_function + "-" + str(
label_noise) + "-" + batch_index
print(batch_index)
if is_curriculum:
dataset_path = curriculum_set
weights = None
if is_init_params:
store = ParamStorage()
if not param_path:
param_path = "./results/params.pkl"
weights = store.load_params(path=param_path)['params']
dataset = DataLoader.create()
dataset.load(dataset_path, dataset_params,
optimization_params.batch_size) #Input stage
model = ConvModel(model_params, verbose=True) #Create network stage
evaluator = Evaluator(model, dataset, optimization_params, dataset_path)
evaluator.run(epochs=epochs, verbose=verbose, init=weights)
report = evaluator.get_result()
network_store_path = filename_params.network_save_name
result_path = filename_params.results + "/results.json"
if is_batch_run:
network_store_path = filename_params.results + "/batch" + batch_index + ".pkl"
result_path = filename_params.results + "/batch" + batch_index + ".json"
storage = ParamStorage(path=network_store_path)
storage.store_params(model.params)
dataset.destroy()
if visual_params.gui_enabled:
interface.server.stop_job(report)
printing.print_section('Evaluation precision and recall')
prc = PrecisionRecallCurve(pr_path, model.params, model_params,
dataset_params)
test_datapoints = prc.get_curves_datapoints(optimization_params.batch_size,
set_name="test")
valid_datapoints = prc.get_curves_datapoints(
optimization_params.batch_size, set_name="valid")
#Stores the model params. Model can later be restored.
printing.print_section('Storing model parameters')
if visual_params.gui_enabled:
interface.server.send_precision_recall_data(test_datapoints,
valid_datapoints)
storage.store_result(result_path, evaluator.events, test_datapoints,
valid_datapoints)
except:
parser.print_help()
sys.exit(0)
# data_loader를 이용해서 전체 데이터셋 가져옴
DATASET_PATH = './data'
extern_data = []
# 가져온 문장별 데이터셋을 이용해서 각종 정보 및 학습셋 구성
dataset = Dataset(parameter, extern_data)
dev_dataset = Dataset(parameter, extern_data)
# Model 불러오기
if parameter["use_conv_model"]:
model = ConvModel(dataset.parameter)
print("[Use Conv with lstm...]")
else:
model = Model(dataset.parameter)
print("[Use original lstm...]")
model.build_model()
# tensorflow session 생성 및 초기화
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# 학습
if parameter["mode"] == "train":
extern_data = data_loader(DATASET_PATH)
# random.shuffle(extern_data) # shuffle input data
es, f2i = load_sentences(args.test,
embeddings.vocab,
f2i,
args.clean,
args.chars,
args.mxlen,
mxfiltsz,
vec_alloc=long_0_tensor_alloc2,
ExType=TorchExamples)
print('Loaded test data')
nc = len(f2i)
mdsave(f2i, embeddings.vocab, args.outdir, args.save)
model = ConvModel(embeddings, nc, args.filtsz, args.cmotsz, args.hsz,
args.dropout, not args.static)
trainer = Trainer(gpu, model, args.optim, args.eta, args.mom)
max_acc = 0
last_improved = 0
for i in range(args.epochs):
print('Training epoch %d' % (i + 1))
trainer.train(ts, args.batchsz)
this_acc = trainer.test(vs, args.batchsz, 'Validation')
if this_acc > max_acc:
max_acc = this_acc
last_improved = i
model.save(args.outdir, args.save)
print('Highest dev acc achieved yet -- writing model')
if not os.path.exists('./ckpt/'):
os.makedirs('./ckpt/')
if not os.path.exists('./iter_num/' + args.model_name):
os.makedirs('./iter_num/' + args.model_name)
if not os.path.exists('./logs/' + args.model_name):
os.makedirs('./logs/' + args.model_name)
if not os.path.exists('./labels/' + args.model_name):
os.makedirs('./labels/' + args.model_name)
if not os.path.exists('./c/'):
os.makedirs('./c/')
dataset = Dataset(args)
change_itr = range(8000, 100000, 4000)
logger = Logger('./logs/' + args.model_name)
if args.env_name == 'bimgame':
model = ConvModel(3, args.num_subgoals, use_rnn=False).to(device)
else:
model = MLPModel(46, args.num_subgoals, use_rnn=False).to(device)
start_itr = 0
c = []
if args.one_class:
if args.pretrained_ckpt is not None:
model.load_state_dict(
torch.load('./ckpt/' + args.pretrained_ckpt + '.pkl'))
start_itr = np.load('./iter_num/' + args.pretrained_ckpt + '.npy')
c = torch.from_numpy(
np.load('./c/' + args.pretrained_ckpt +
'.npy')).float().to(device)
# computing initial c for one-class out-of-set estimation
if len(c) == 0:
parser.add_argument('--max_sentence_len',
type=int,
default=20,
help='maximum sentence length')
parser.add_argument('--data_n_samples',
type=int,
default=100,
help='number of samples per color, shape combination')
args = parser.parse_args()
images_dict = load_images_dict(args.data_n_samples)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
agent1 = ConvModel(vocab_size=args.vocab_size).to(device)
agent2 = ConvModel(vocab_size=args.vocab_size).to(device)
loss_fn = NLLLoss()
optimizer1 = torch.optim.Adam(
[p for p in agent1.parameters() if p.requires_grad], args.lr)
optimizer2 = torch.optim.Adam(
[p for p in agent2.parameters() if p.requires_grad], args.lr)
def get_message(s):
return ''.join(
[chr(97 + int(v.cpu().data)) for v in s if v < args.vocab_size])
import numpy as np
import torch.nn as nn
import torch
from model import ConvModel
device = torch.device('cpu')
M = 1
Tx = 50
model = ConvModel().to(device)
int(len(all_split) * 0.8):]
dataloader = DataLoader(train_set,
batch_size=batch_size,
num_workers=n_cpu,
sampler=RandomSampler(train_split))
valid_dataloader = DataLoader(train_set,
batch_size=batch_size,
num_workers=n_cpu,
sampler=RandomSampler(val_split))
if load_model:
with open(load_model_path, 'rb') as f:
net = log.load_model().to(device)
else:
net = ConvModel(1024, 2).to(device)
optimizer = torch.optim.Adam(net.parameters())
loss_func = F.binary_cross_entropy
print('start trainning ......')
for e in range(epochs):
net.train()
for i, batchs in enumerate(dataloader):
sig, other, label = batchs['sig'].to(device), batchs['other'].to(
device), batchs['label'].to(device)
out = net(sig, other)
loss = loss_func(out, label)
optimizer.zero_grad()
