def _load_chainer_model(self):
model_name = rospy.get_param('~model_name')
if rospy.has_param('~model_h5'):
rospy.logwarn('Rosparam ~model_h5 is deprecated,'
' and please use ~model_file instead.')
model_file = rospy.get_param('~model_h5')
else:
model_file = rospy.get_param('~model_file')
n_class = len(self.target_names)
if model_name == 'fcn32s':
self.model = fcn.models.FCN32s(n_class=n_class)
elif model_name == 'fcn16s':
self.model = fcn.models.FCN16s(n_class=n_class)
elif model_name == 'fcn8s':
self.model = fcn.models.FCN8s(n_class=n_class)
elif model_name == 'fcn8s_at_once':
self.model = fcn.models.FCN8sAtOnce(n_class=n_class)
else:
raise ValueError('Unsupported ~model_name: {}'.format(model_name))
rospy.loginfo('Loading trained model: {0}'.format(model_file))
if model_file.endswith('.npz'):
S.load_npz(model_file, self.model)
else:
S.load_hdf5(model_file, self.model)
rospy.loginfo('Finished loading trained model: {0}'.format(model_file))
if self.gpu != -1:
self.model.to_gpu(self.gpu)
if LooseVersion(chainer.__version__) < LooseVersion('2.0.0'):
self.model.train = False
def load_states(stage_cnt, joint_idx):
''' Load model, optimizer, and losses '''
_, model, optimizer, _, _ = setup_initial_states(stage_cnt)
modif = create_modifier(stage_cnt, joint_idx)
# Alexnet model
filename = settings.RESUME_MODEL % modif
logger.info('Load model from %s', filename)
serializers.load_npz(filename, model)
if settings.GPU >= 0: # GPU setup
cuda.get_device(settings.GPU).use()
model.to_gpu()
# Optimizer
optimizer.setup(model)
filename = settings.RESUME_OPTIMIZER % modif
logger.info('Load optimizer from %s', filename)
serializers.load_npz(filename, optimizer)
# Losses
filename = settings.RESUME_LOSS % modif
logger.info('Load loss history from %s', filename)
loss_data = np.load(filename)
train_losses = loss_data['train'].tolist()
test_losses = loss_data['test'].tolist()
assert(len(train_losses) == len(test_losses))
# Epoch count
epoch_cnt = len(train_losses)
logger.info('Resume from epoch %d', epoch_cnt)
return epoch_cnt, model, optimizer, train_losses, test_losses
def __init__(self, pretrained_model='auto'):
super(HyperFaceModel, self).__init__(
conv1 = L.Convolution2D(3, 96, 11, stride=4, pad=0),
conv1a = L.Convolution2D(96, 256, 4, stride=4, pad=0),
conv2 = L.Convolution2D(96, 256, 5, stride=1, pad=2),
conv3 = L.Convolution2D(256, 384, 3, stride=1, pad=1),
conv3a = L.Convolution2D(384, 256, 2, stride=2, pad=0),
conv4 = L.Convolution2D(384, 384, 3, stride=1, pad=1),
conv5 = L.Convolution2D(384, 256, 3, stride=1, pad=1),
conv_all = L.Convolution2D(768, 192, 1, stride=1, pad=0),
fc_full = L.Linear(6 * 6 * 192, 3072),
fc_detection1 = L.Linear(3072, 512),
fc_detection2 = L.Linear(512, 2),
fc_landmarks1 = L.Linear(3072, 512),
fc_landmarks2 = L.Linear(512, 42),
fc_visibility1 = L.Linear(3072, 512),
fc_visibility2 = L.Linear(512, 21),
fc_pose1 = L.Linear(3072, 512),
fc_pose2 = L.Linear(512, 3),
fc_gender1 = L.Linear(3072, 512),
fc_gender2 = L.Linear(512, 2),
)
# download pretrained weights
if pretrained_model == 'auto':
rospy.loginfo("Loading pretrained model. (This may take some minutes.)")
url = 'https://jsk-ros-pkg.s3.amazonaws.com/chainer/hyperface_model_epoch_190.npz'
load_npz(download.cached_download(url), self)
rospy.loginfo("Model loaded")
elif pretrained_model:
rospy.loginfo("Loading pretrained model: %s" % pretrained_model)
load_npz(pretrained_model, self)
rospy.loginfo("Model loaded")
else:
rospy.logwarn("No pretrained model is loaded.")
def main(game_count=20):
path = Trainer.model_path()
env = gym.make(Q.ENV_NAME)
q = Q(Q.hidden, env.action_space.n)
agent = Agent(0.0, list(range(env.action_space.n)))
serializers.load_npz(path, q)
for i in range(Q.D):
Trainer.print_model(i, q)
for i_episode in range(game_count):
observation = env.reset()
prev = None
step = 0
episode_reward = 0
while True:
#env.render()
s, a, _, _ = Trainer.act(observation, q, agent, prev)
prev = s
observation, reward, done, info = env.step(a)
episode_reward += reward
step += 1
if done:
print("episode {} has done. reward is {}. step is {}."
.format(i_episode, episode_reward, step))
break
elif step >= 1000:
print("episode {} has faield. reward is {}. step is {}."
.format(i_episode, episode_reward, step))
break
def _test_trigger(self, trigger, key, accuracies, expected,
resume=None, save=None):
trainer = testing.get_trainer_with_mock_updater(
stop_trigger=(len(accuracies), 'iteration'),
iter_per_epoch=self.iter_per_epoch)
updater = trainer.updater
def _serialize_updater(serializer):
updater.iteration = serializer('iteration', updater.iteration)
updater.epoch = serializer('epoch', updater.epoch)
updater.is_new_epoch = serializer(
'is_new_epoch', updater.is_new_epoch)
trainer.updater.serialize = _serialize_updater
def set_observation(t):
t.observation = {key: accuracies[t.updater.iteration-1]}
trainer.extend(set_observation, name='set_observation',
trigger=(1, 'iteration'), priority=2)
invoked_iterations = []
def record(t):
invoked_iterations.append(t.updater.iteration)
trainer.extend(record, name='record', trigger=trigger, priority=1)
if resume is not None:
serializers.load_npz(resume, trainer)
trainer.run()
self.assertEqual(invoked_iterations, expected)
if save is not None:
serializers.save_npz(save, trainer)
def load_policy_network(name):
in_dim = preprocessing.state_to_tensor.features
out_dim = preprocessing.action_to_tensor.features
model = L.Classifier(policy.Policy(in_dim, out_dim))
serializers.load_npz('%s.model.npz' % name, model)
def policy_network(gs):
state = preprocessing.state_to_tensor(gs)
Y = model.predictor([state]).data[0]
actions = []
for idx, pos in gs.legal_moves():
action = preprocessing.action_to_tensor(gs, idx, pos, gs.size)
actions.append(action)
# 确保即使actions为空列表，也要构造一个int型的空np数组
actions = np.array(actions, dtype=np.int32)
Y = Y[actions]
Y = Y.reshape((1, Y.size))
Y = Variable(Y)
P = F.softmax(Y).data[0]
for idx, pos in enumerate(gs.legal_moves()):
yield pos, P[idx]
return policy_network
def __init__(self, arch=None, weights_file=None, model=None, device=-1):
# test
# self.model = params['archs']['nn1']()
# serializers.load_npz('result/nn1/model_iter_50000', self.model)
print('Loading PoseNet...')
self.model = params['archs']['posenet']()
serializers.load_npz('models/coco_posenet.npz', self.model)
# if model is not None:
# self.model = model
# else:
# # load model
# print('Loading PoseNet...')
# self.model = params['archs'][arch]()
# if weights_file:
# serializers.load_npz(weights_file, self.model)
self.device = device
if self.device >= 0:
cuda.get_device_from_id(device).use()
self.model.to_gpu()
# create gaussian filter
ksize = params['ksize']
kernel = cuda.to_gpu(self.create_gaussian_kernel(sigma=params['gaussian_sigma'], ksize=ksize))
self.gaussian_kernel = kernel
def get_model(args):
model_fn = os.path.basename(args.model)
model_name = model_fn.split('.')[0]
model = imp.load_source(model_name, args.model)
model = getattr(model, model_name)
model = model(args.joint_num)
if 'result_dir' in args:
dst = '%s/%s' % (args.result_dir, model_fn)
if not os.path.exists(dst):
shutil.copy(args.model, dst)
dst = '%s/%s' % (args.result_dir, os.path.basename(__file__))
if not os.path.exists(dst):
shutil.copy(__file__, dst)
# load model
if args.resume_model is not None:
serializers.load_npz(args.resume_model, model)
# prepare model
if args.gpu >= 0:
model.to_gpu(args.gpu)
return model
def get_model_optimizer(args):
model = get_model(args)
if 'opt' in args:
# prepare optimizer
if args.opt == 'AdaGrad':
optimizer = optimizers.AdaGrad(lr=args.lr)
elif args.opt == 'MomentumSGD':
optimizer = optimizers.MomentumSGD(lr=args.lr, momentum=0.9)
elif args.opt == 'Adam':
optimizer = optimizers.Adam()
else:
raise Exception('No optimizer is selected')
optimizer.setup(model)
if args.resume_opt is not None:
serializers.load_npz(args.resume_opt, optimizer)
args.epoch_offset = int(
re.search('epoch-([0-9]+)', args.resume_opt).groups()[0])
return model, optimizer
else:
print('No optimizer generated.')
return model
def main(argv):
if len(argv) < 4:
print "Usage: %s [sp|mlp|cnn] model_path image_path" % argv[0]
sys.exit()
type = argv[1]
model_path = argv[2]
image_path = argv[3]
if type == "sp":
model = L.Classifier(net.MnistSP())
elif type == "cnn":
model = L.Classifier(net.MnistCNN())
else:
model = L.Classifier(net.MnistMLP())
serializers.load_npz(model_path, model)
print("input:\t%s" % image_path)
x = load_image(image_path)
x = chainer.Variable(np.asarray([x]))
r = classify(model, x)
print("output:")
for i in range(len(r.data[0])):
print "\t%d: %f" % (i , r.data[0][i])
print("class:\t%d" % np.argmax(r.data[0]))
def get_model(gpu):
model = FasterRCNN(trunk_class=VGG16Prev)
model.rcnn_train = False
model.rpn_train = False
serializers.load_npz('data/VGG16_faster_rcnn_final.model', model)
return model
def main():
# define options
parser = argparse.ArgumentParser(
description='Training script of DenseNet on CIFAR-10 dataset')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='result',
help='Output directory')
parser.add_argument('--numlayers', '-L', type=int, default=40,
help='Number of layers')
args = parser.parse_args()
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
# setup model
model = L.Classifier(MyModel(10))
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu()
# そのオブジェクトに保存済みパラメータをロードする
serializers.load_npz('result/model_20.npz', model)
for i in range(10, 15):
predict(model, i, test)
def get_optimizer(model, opt, lr, adam_alpha=None, adam_beta1=None,
adam_beta2=None, adam_eps=None, weight_decay=None,
resume_opt=None):
if opt == 'MomentumSGD':
optimizer = optimizers.MomentumSGD(lr=lr, momentum=0.9)
elif opt == 'Adam':
optimizer = optimizers.Adam(
alpha=adam_alpha, beta1=adam_beta1,
beta2=adam_beta2, eps=adam_eps)
elif opt == 'AdaGrad':
optimizer = optimizers.AdaGrad(lr=lr)
elif opt == 'RMSprop':
optimizer = optimizers.RMSprop(lr=lr)
else:
raise Exception('No optimizer is selected')
# The first model as the master model
optimizer.setup(model)
if opt == 'MomentumSGD':
optimizer.add_hook(
chainer.optimizer.WeightDecay(weight_decay))
if resume_opt is not None:
serializers.load_npz(resume_opt, optimizer)
return optimizer
def onCompVsCompLoop(self, event):
loop_max = self.auto_loop_textctrl.GetValue()
if loop_max == "":
self.showWarnDlg("Set loop count.")
return
if self.radio_box.GetSelection() != 3:
self.showWarnDlg("Select \"Computer vs Computer\".")
return
loop_max = int(loop_max)
print loop_max
comp_a_win_num = 0
comp_b_win_num = 0
draw_num = 0
self.comp_a_win_num_label.SetValue("0")
self.comp_b_win_num_label.SetValue("0")
self.draw_num_label.SetValue("0")
# match record file check
if os.path.exists("./record.log"):
os.remove("./record.log")
for loop_cnt in range(0,loop_max):
self.setInitialState()
if self.comp_ai_a_cb.GetValue() == "MLP" or self.comp_ai_b_cb.GetValue() == "MLP":
model_name_black = str(self.mlp_for_black_text.GetValue())
model_name_white = str(self.mlp_for_black_text.GetValue())
serializers.load_npz(model_name_black, gMlpModelBlack)
serializers.load_npz(model_name_white, gMlpModelWhite)
if model_name_black.find("puttable_mark") != -1 and\
model_name_white.find("puttable_mark") != -1 :
self.puttable_mark = True
if self.comp_ai < 0:
black_computer = "A"
else:
black_computer = "B"
for i in range(0,4):
self.radio_box.EnableItem(i, False)
self.doComputer(True)
score_black = self.score_black_label.GetValue()
score_white = self.score_white_label.GetValue()
if int(score_black) == int(score_white):
draw_num += 1
elif (int(score_black) > int(score_white) and black_computer == "A") or \
(int(score_black) < int(score_white) and black_computer == "B"):
comp_a_win_num += 1
else:
comp_b_win_num += 1
self.outputRecord()
self.comp_a_win_num_label.SetValue(str(comp_a_win_num))
self.comp_b_win_num_label.SetValue(str(comp_b_win_num))
self.draw_num_label.SetValue(str(draw_num))
def main(game_count=20):
path = Trainer.model_path()
env = gym.make("FrozenLake-v0")
q = Q(Q.hidden, env.action_space.n)
agent = Agent(0.0, list(range(env.action_space.n)))
serializers.load_npz(path, q)
for i in range(Q.D):
Trainer.print_model(i, q)
for i_episode in range(game_count):
observation = env.reset()
prev = None
step = 0
while True:
#env.render()
s, a, _, _ = Trainer.act(observation, q, agent, prev)
prev = s
observation, reward, done, info = env.step(a)
if done:
print("episode {} has done. reward is {}. its length is {}.".format(i_episode, reward, step))
break
else:
step += 1
def main():
with open('./word2index.dict', 'rb') as f:
word2index = dill.load(f)
with open('./index2word.dict', 'rb') as f:
index2word = dill.load(f)
model = Seq2Seq(
vocab_size=len(word2index),
embed_size=300,
hidden_size=300,
)
serializers.load_npz('seq2seq.npz', model)
while True:
s = input()
test_input = Variable(
np.array([word2index.get(word, word2index['UNK']) for word in mecab_wakati(s)], dtype='int32')
)
print('入力-> {}'.format(s))
print('出力-> ', end="")
for index in model.predict(test_input):
print(index2word[index], end='')
print()
def generate(img):
parser = argparse.ArgumentParser(description='Real-time style transfer image generator')
#parser.add_argument('input')
args = parser.parse_args()
model = FastStyleNet()
serializers.load_npz('models/seurat.model', model)
if -1 >= 0:
cuda.get_device(-1).use()
model.to_gpu()
xp = np if -1 < 0 else cuda.cupy
start = time.time()
image = xp.asarray(Image.open(img).convert('RGB'), dtype=xp.float32).transpose(2, 0, 1)
image = image.reshape((1,) + image.shape)
x = Variable(image)
y = model(x)
result = cuda.to_cpu(y.data)
result = result.transpose(0, 2, 3, 1)
result = result.reshape((result.shape[1:]))
result = np.uint8(result)
print(time.time() - start, 'sec')
# Image.fromarray(result).save(args.out)
return Image.fromarray(result)
def read_lstm_model(self, params, train):
assert train == False # reading a model to continue training is currently not supported
words_file = params['config_path'] + params['words_file']
model_file = params['config_path'] + params['model_file']
unit = int(params['unit'])
deep = (params['deep'] == 'yes')
drop_ratio = float(params['drop_ratio'])
#read and normalize target word embeddings
w, word2index, index2word = self.read_words(words_file)
s = numpy.sqrt((w * w).sum(1))
s[s==0.] = 1.
w /= s.reshape((s.shape[0], 1)) # normalize
context_word_units = unit
lstm_hidden_units = IN_TO_OUT_UNITS_RATIO*unit
target_word_units = IN_TO_OUT_UNITS_RATIO*unit
cs = [1 for _ in range(len(word2index))] # dummy word counts - not used for eval
loss_func = L.NegativeSampling(target_word_units, cs, NEGATIVE_SAMPLING_NUM) # dummy loss func - not used for eval
model = BiLstmContext(deep, self.gpu, word2index, context_word_units, lstm_hidden_units, target_word_units, loss_func, train, drop_ratio)
S.load_npz(model_file, model)
return w, word2index, index2word, model
def test_resumed_trigger_sparse_call(self):
trainer = testing.get_trainer_with_mock_updater(
stop_trigger=None, iter_per_epoch=self.iter_per_epoch)
accumulated = False
with tempfile.NamedTemporaryFile(delete=False) as f:
trigger = training.triggers.ManualScheduleTrigger(*self.schedule)
for expected, finished in zip(self.expected[:self.resume],
self.finished[:self.resume]):
trainer.updater.update()
accumulated = accumulated or expected
if random.randrange(2):
self.assertEqual(trigger(trainer), accumulated)
self.assertEqual(trigger.finished, finished)
accumulated = False
serializers.save_npz(f.name, trigger)
trigger = training.triggers.ManualScheduleTrigger(*self.schedule)
serializers.load_npz(f.name, trigger)
for expected, finished in zip(self.expected[self.resume:],
self.finished[self.resume:]):
trainer.updater.update()
accumulated = accumulated or expected
if random.randrange(2):
self.assertEqual(trigger(trainer), accumulated)
self.assertEqual(trigger.finished, finished)
accumulated = False
def load(self, path=None):
if path is not None:
serializers.load_npz(path+'/model.npz', self.model)
serializers.load_npz(path+'/optimizer.npz', self.opt)
self.best_model = copy.deepcopy(self.model)
self.best_opt = copy.deepcopy(self.opt)
else:
return 0
def loadModelAndOptimizer():
"""モデルとオプティマイザ読み込み"""
if modelFile and path.isfile(modelFile):
print('Load model from', modelFile)
serializers.load_npz(modelFile, dnn.model)
if stateFile and path.isfile(stateFile):
print('Load optimizer state from', stateFile)
serializers.load_npz(stateFile, dnn.optimizer)
def load_models(self, models):
models = models.split(',')
availiable_path = 'models_availiable'
update_path = 'models_upload'
all_models = 'models'
models_availiable = os.listdir(availiable_path)
models_upload = os.listdir(update_path)
self.models = {m.split('.')[0].split('_')[0]:availiable_path +'/'+ m
for m in models_availiable}
for m in models_upload:
model_name = m.split('.')[0].split('_')[0]
if not self.models.has_key(model_name):
cmd = 'mv {update}/{update_name} {availiable}/'.format(
update=update_path, update_name=m,
availiable=availiable_path)
(status, output) = commands.getstatusoutput(cmd)
self.models[model_name] = availiable_path + '/' + m
else:
cmd = 'mv {availiable} {all_models}'.format(
availiable=self.models[model_name],
all_models=all_models)
(status, output) = commands.getstatusoutput(cmd)
cmd = 'mv {update}/{update_name} {availiable}/'.format(
update=update_path, update_name=m,
availiable=availiable_path)
(status, output) = commands.getstatusoutput(cmd)
self.models[model_name] = availiable_path + '/' + m
# init denoise
file_name = 'denoise.txt'
if os.path.exists(file_name):
with open(file_name, 'r') as pf:
for line in pf.readlines():
line = line.strip().split(' ')
self.denoise[line[0].strip()] = float(line[-1].strip())
# init model
for model_name,value in self.models.items():
# model_name = m.split('/')[-1].split('.')[0]
handle_model = FastStyleNet()
serializers.load_npz(value, handle_model)
if self.args.gpu >= 0:
cuda.get_device(self.args.gpu).use()
handle_model.to_gpu()
self.models[model_name] = handle_model
load_all_models = ', '.join(self.models.keys())
logging.info('loading models : ' + load_all_models)
logging.info('load success')
def load_model(args):
model_fn = os.path.basename(args.model)
model_name = model_fn.split('.')[0]
model = imp.load_source(model_name, args.model)
model = getattr(model, model_name)
model = model(args.joint_num)
serializers.load_npz(args.param, model)
model.train = False
return model
def __init__(self, enable_controller=[0, 1, 3, 4]):
self.num_of_actions = len(enable_controller)
self.enable_controller = enable_controller # Default setting : "Breakout"
print "Initializing DN..."
# Initialization of Chainer 1.1.0 or older.
# print "CUDA init"
# cuda.init()
print "Model Building"
self.model = FunctionSet(
l1=F.Convolution2D(4, 32, ksize=8, stride=4, nobias=False, wscale=np.sqrt(2)),
l2=F.Convolution2D(32, 64, ksize=4, stride=2, nobias=False, wscale=np.sqrt(2)),
l3=F.Convolution2D(64, 64, ksize=3, stride=1, nobias=False, wscale=np.sqrt(2)),
l4=F.Linear(3136, 256, wscale=np.sqrt(2)),
l5=F.Linear(3136, 256, wscale=np.sqrt(2)),
l6=F.Linear(256, 1, initialW=np.zeros((1, 256), dtype=np.float32)),
l7=F.Linear(256, self.num_of_actions, initialW=np.zeros((self.num_of_actions, 256),
dtype=np.float32)),
q_value=DN_out.DN_out(1, self.num_of_actions, self.num_of_actions, nobias = True)
).to_gpu()
if args.resumemodel:
# load saved model
serializers.load_npz(args.resumemodel, self.model)
print "load model from resume.model"
self.model_target = copy.deepcopy(self.model)
print "Initizlizing Optimizer"
self.optimizer = optimizers.RMSpropGraves(lr=0.00025, alpha=0.95, momentum=0.95, eps=0.0001)
self.optimizer.setup(self.model.collect_parameters())
# History Data : D=[s, a, r, s_dash, end_episode_flag]
if args.resumeD1 and args.resumeD2:
# load saved D1 and D2
npz_tmp1 = np.load(args.resumeD1)
print "finished loading half of D data"
npz_tmp2 = np.load(args.resumeD2)
self.D = [npz_tmp1['D0'],
npz_tmp1['D1'],
npz_tmp1['D2'],
npz_tmp2['D3'],
npz_tmp2['D4']]
npz_tmp1.close()
npz_tmp2.close()
print "loaded stored all D data"
else:
self.D = [np.zeros((self.data_size, 4, 84, 84), dtype=np.uint8),
np.zeros(self.data_size, dtype=np.uint8),
np.zeros((self.data_size, 1), dtype=np.int8),
np.zeros((self.data_size, 4, 84, 84), dtype=np.uint8),
np.zeros((self.data_size, 1), dtype=np.bool)]
print "initialized D data"
def load(load_dir, epoch):
with (load_dir/meta_name).open('rb') as f:
storage = Storage(*np.load(f)[0])
serializers.load_npz(
str(load_dir/model_name(epoch)),
storage.model
)
serializers.load_npz(
str(load_dir/optimizer_name(epoch)),
storage.optimizer
)
return storage
def load_best_model(stage_cnt, joint_idx, gpu=False, train=False):
modif = create_modifier(stage_cnt, joint_idx)
filename = settings.BEST_MODEL % modif
logger.info('Load model from %s', filename)
if not os.path.exists(filename):
raise FileNotFoundError
model = setup_model(stage_cnt)
serializers.load_npz(filename, model)
if settings.GPU >= 0: # GPU setup
cuda.get_device(settings.GPU).use()
model.to_gpu()
model.train = train
return model
def __init__(self, kwargs):
print "ImageHandleTask init ..."
self.models ={}
self.args = kwargs['args']
self.xp = np if self.args.gpu < 0 else cuda.cupy
#""" # load image model
self.model = FastStyleNet()
serializers.load_npz(self.args.model, self.model)
if self.args.gpu >= 0:
cuda.get_device(self.args.gpu).use()
slef.model.to_gpu()
def recognize(image):
model = L.Classifier(net.MyChain())
serializers.load_npz("animeface.model", model)
x = np.array([image], np.float32)[[0]]
x = Variable(x)
y = model.predictor(x)
ys = list(y.data[0])
class_id = ys.index(max(ys))
tag2id = animeface.get_class_id_table()
id2tag = {tag2id[tag]: tag for tag in tag2id}
print id2tag[class_id]
def __init__(self, arch=None, weights_file=None, model=None, device=-1):
print('Loading FaceNet...')
self.model = params['archs'][arch]()
serializers.load_npz(weights_file, self.model)
self.device = device
if self.device >= 0:
cuda.get_device_from_id(device).use()
self.model.to_gpu()
# create gaussian filter
ksize = params['ksize']
kernel = cuda.to_gpu(self.create_gaussian_kernel(sigma=params['gaussian_sigma'], ksize=ksize))
self.gaussian_kernel = kernel
def load_models(self, models):
models = models.split(',')
for m in models:
model_name = m.split('/')[-1].split('.')[0]
handle_model = FastStyleNet()
serializers.load_npz(m, handle_model)
if self.args.gpu >= 0:
cuda.get_device(self.args.gpu).use()
handle_model.to_gpu()
self.models[model_name] = handle_model
def main():
parser = argparse.ArgumentParser(description='Chainer example: MNIST')
parser.add_argument('--initmodel',
'-m',
default='',
help='Initialize the model from given file')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=20,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result/2',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--unit',
'-u',
type=int,
default=50,
help='Number of units')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# unit: {}'.format(args.unit))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
model = mlp.MLP(args.unit, 10)
classifier_model = L.Classifier(model)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
classifier_model.to_gpu() # Copy the model to the GPU
xp = np if args.gpu < 0 else cuda.cupy
# Setup an optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(classifier_model)
# Load the MNIST dataset
train, test = chainer.datasets.get_mnist()
batchsize = args.batchsize
n_epoch = args.epoch
N = len(train) # training data size
N_test = len(test) # test data size
# Init/Resume
if args.initmodel:
print('Load model from', args.initmodel)
serializers.load_npz(args.initmodel, classifier_model)
if args.resume:
print('Load optimizer state from', args.resume)
serializers.load_npz(args.resume, optimizer)
if not os.path.exists(args.out):
os.makedirs(args.out)
# Learning loop
for epoch in six.moves.range(1, n_epoch + 1):
print('epoch', epoch)
# training
perm = np.random.permutation(N)
sum_accuracy = 0
sum_loss = 0
start = time.time()
for i in six.moves.range(0, N, batchsize):
x = chainer.Variable(xp.asarray(train[perm[i:i + batchsize]][0]))
t = chainer.Variable(xp.asarray(train[perm[i:i + batchsize]][1]))
# Pass the loss function (Classifier defines it) and its arguments
optimizer.update(classifier_model, x, t)
if epoch == 1 and i == 0:
with open('{}/graph.dot'.format(args.out), 'w') as o:
g = computational_graph.build_computational_graph(
(classifier_model.loss, ))
o.write(g.dump())
print('graph generated')
sum_loss += float(classifier_model.loss.data) * len(t.data)
sum_accuracy += float(classifier_model.accuracy.data) * len(t.data)
end = time.time()
elapsed_time = end - start
throughput = N / elapsed_time
print(
'train mean loss={}, accuracy={}, throughput={} images/sec'.format(
sum_loss / N, sum_accuracy / N, throughput))
# evaluation
sum_accuracy = 0
sum_loss = 0
for i in six.moves.range(0, N_test, batchsize):
index = np.asarray(list(range(i, i + batchsize)))
x = chainer.Variable(xp.asarray(test[index][0]))
t = chainer.Variable(xp.asarray(test[index][1]))
with chainer.no_backprop_mode():
# When back propagation is not necessary,
# we can omit constructing graph path for better performance.
# `no_backprop_mode()` is introduced from chainer v2,
# while `volatile` flag was used in chainer v1.
loss = classifier_model(x, t)
sum_loss += float(loss.data) * len(t.data)
sum_accuracy += float(classifier_model.accuracy.data) * len(t.data)
print('test mean loss={}, accuracy={}'.format(sum_loss / N_test,
sum_accuracy / N_test))
# Save the model and the optimizer
print('save the model')
serializers.save_npz('{}/classifier.model'.format(args.out),
classifier_model)
serializers.save_npz('{}/mlp.model'.format(args.out), model)
print('save the optimizer')
serializers.save_npz('{}/mlp.state'.format(args.out), optimizer)
def main(args):
s_list = args.savedir
np.random.seed(4517)
# Get data
data = data_utils.assemble_data()
data_idx = np.random.permutation(len(data))
cutoff = int(len(data) * 0.8)
test = data[data_idx[cutoff:], :, :, :]
test = np.reshape(test, (test.shape[0], 3, 32, 32))
d_list = []
kl1_list = []
kl2_list = []
for i, savedir in enumerate(s_list):
autoencoder = OurClassifier(OurAutoencoder())
serializers.load_npz(os.path.join(savedir, 'autoencoder.model'),
autoencoder)
mse_decoding_sample = np.zeros((test.shape[0], 1))
kl1_decoding_sample = np.zeros((test.shape[0], 1))
kl2_decoding_sample = np.zeros((test.shape[0], 1))
# Compute MSE for all test images
for index in tqdm(range(test.shape[0]), desc='All test images'):
img = test[index, 0, :, :]
img2 = test[index, 1, :, :]
target = test[index, 2, :, :]
m, s, m2, s2 = autoencoder.encode(np.reshape(img, (1, 1, 32, 32)),
np.reshape(img2, (1, 1, 32, 32)))
kl1_decoding_sample[index] = F.gaussian_kl_divergence(m,
s).data / 32
kl2_decoding_sample[index] = F.gaussian_kl_divergence(m2,
s2).data / 32
sample1 = F.gaussian(m, s)
sample2 = F.gaussian(m2, s2)
sample = F.concat((sample1, sample2))
# Reconstruct using sample given m,s
decoding_sample = np.reshape(
autoencoder.decode(sample, for_plot=True).data, (32, 32))
mse_decoding_sample[index] = chainer.functions.mean_squared_error(
target, decoding_sample).data
d_list.append(mse_decoding_sample)
kl1_list.append(kl1_decoding_sample)
kl2_list.append(kl2_decoding_sample)
# Use paired sample t-test to find out if performance is significantly different
d_significance = []
kl1_significance = []
kl2_significance = []
if (len(s_list) > 1):
for k in range(1, len(s_list)):
# binwidth = 0.02
# plt.figure()
# plt.hist(kl2_list[k],bins=np.arange(np.min(kl2_list[k]), np.max(kl2_list[k]) + binwidth, binwidth),label='No Log')
# plt.hist(np.log(kl2_list[k]),bins=np.arange(np.min(np.log(kl2_list[k])), np.max(np.log(kl2_list[k])) + binwidth, binwidth))
# plt.legend()
# plt.hist(np.log(d_list[k-1]),bins=np.arange(np.min(np.log(d_list[k-1])), np.max(np.log(d_list[k-1])) + binwidth, binwidth))
# plt.title('Log of Reconstruction MSE (with sampling)')
p = stats.ttest_rel(np.log(d_list[k - 1]), np.log(d_list[k]))[1]
if p < 0.05:
d_significance.append(k - 0.5)
p = stats.ttest_rel(np.log(kl1_list[k - 1]),
np.log(kl1_list[k]))[1]
if p < 0.05:
kl1_significance.append(k - 0.5)
p = stats.ttest_rel(np.log(kl2_list[k - 1]),
np.log(kl2_list[k]))[1]
if p < 0.05:
kl2_significance.append(k - 0.5)
d_means = [np.mean(ary) for ary in d_list]
d_stds = [np.std(ary) for ary in d_list]
kl1_means = [np.mean(ary) for ary in kl1_list]
kl1_std = [np.std(ary) for ary in kl1_list]
kl2_means = [np.mean(ary) for ary in kl2_list]
kl2_std = [np.std(ary) for ary in kl2_list]
# Print for table in paper
print('MSE')
for index, m in enumerate(d_means):
print s_list[index] + " " + "{:.06f}".format(
m) + " & " + "{:.04f}".format(d_stds[index]) + " \\\\"
print('KL1')
for index, m in enumerate(kl1_means):
print s_list[index] + " " + "{:.06f}".format(
m) + " & " + "{:.04f}".format(kl1_std[index]) + " \\\\"
print('KL2')
for index, m in enumerate(kl2_means):
print s_list[index] + " " + "{:.06f}".format(
m) + " & " + "{:.04f}".format(kl2_std[index]) + " \\\\"
# Plot MSE
plt.figure()
for j in range(len(d_means)):
plt.errorbar(j,
d_means[j],
d_stds[j],
label="Model {}".format(j + 1),
marker='^')
if (len(s_list) > 1):
plt.scatter(d_significance,
np.zeros((len(d_significance), 1)),
marker='*')
plt.xlim([-0.5, len(d_means) - 0.5])
tenth = (np.max(d_means) - np.min(d_means)) / 10
# plt.ylim([-tenth,np.max(d_means)+tenth])
plt.title('Reconstruction MSE')
plt.legend(loc=2)
frame1 = plt.gca()
frame1.axes.xaxis.set_ticklabels([])
# Plot KL1
plt.figure()
for j in range(len(kl1_means)):
plt.errorbar(j,
kl1_means[j],
kl1_std[j],
label="Model {}".format(j + 1),
marker='^')
if (len(s_list) > 1):
plt.scatter(kl1_significance,
np.ones((len(kl1_significance), 1)) * 0.2,
marker='*')
plt.xlim([-0.5, len(kl1_means) - 0.5])
tenth = (np.max(kl1_means) - np.min(kl1_means)) / 10
# plt.ylim([-tenth,np.max(d_means)+tenth])
plt.title('Encoding KL divergence Enc1')
plt.legend(loc=1)
frame1 = plt.gca()
frame1.axes.xaxis.set_ticklabels([])
# Plot KL2
plt.figure()
for j in range(len(kl2_means)):
plt.errorbar(j,
kl2_means[j],
kl2_std[j],
label="Model {}".format(j + 1),
marker='^')
if (len(s_list) > 1):
plt.scatter(kl2_significance,
np.ones((len(kl2_significance), 1)) * 0.2,
marker='*')
plt.xlim([-0.5, len(kl2_means) - 0.5])
tenth = (np.max(kl2_means) - np.min(kl2_means)) / 10
# plt.ylim([-tenth,np.max(d_means)+tenth])
plt.title('Encoding KL divergence Enc2')
plt.legend(loc=1)
frame1 = plt.gca()
frame1.axes.xaxis.set_ticklabels([])
plt.show()
def get_fishnet(blocks,
model_name=None,
pretrained=False,
root=os.path.join("~", ".chainer", "models"),
**kwargs):
"""
Create FishNet model with specific parameters.
Parameters:
----------
blocks : int
Number of blocks.
model_name : str or None, default None
Model name for loading pretrained model.
pretrained : bool, default False
Whether to load the pretrained weights for model.
root : str, default '~/.chainer/models'
Location for keeping the model parameters.
"""
if blocks == 99:
direct_layers = [[2, 2, 6], [1, 1, 1], [1, 2, 2]]
skip_layers = [[1, 1, 1, 2], [4, 1, 1, 0]]
elif blocks == 150:
direct_layers = [[2, 4, 8], [2, 2, 2], [2, 2, 4]]
skip_layers = [[2, 2, 2, 4], [4, 2, 2, 0]]
else:
raise ValueError(
"Unsupported FishNet with number of blocks: {}".format(blocks))
direct_channels_per_layers = [[128, 256, 512], [512, 384, 256],
[320, 832, 1600]]
skip_channels_per_layers = [[64, 128, 256, 512], [512, 768, 512, 0]]
direct_channels = [[
[b] * c for (b, c) in zip(*a)
] for a in ([(ci, li)
for (ci,
li) in zip(direct_channels_per_layers, direct_layers)])]
skip_channels = [[
[b] * c for (b, c) in zip(*a)
] for a in ([(ci, li)
for (ci, li) in zip(skip_channels_per_layers, skip_layers)])]
init_block_channels = 64
net = FishNet(direct_channels=direct_channels,
skip_channels=skip_channels,
init_block_channels=init_block_channels,
**kwargs)
if pretrained:
if (model_name is None) or (not model_name):
raise ValueError(
"Parameter `model_name` should be properly initialized for loading pretrained model."
)
from .model_store import get_model_file
load_npz(file=get_model_file(model_name=model_name,
local_model_store_dir_path=root),
obj=net)
return net
import chainer.computational_graph as c
import sys, os, argparse
from chainer import serializers
from userhook import UserHook
import chainer.functions as F
from train import *
from distutils.dir_util import copy_tree
from pdb import *
from userfunc_var import VAR
var = VAR()
model = NeuralNet(50, 10)
serializers.load_npz('mnist.npz', model)
_, test = chainer.datasets.get_mnist()
txs, tts = test._datasets
def infer(inp):
print("*** infer ***")
# inp=0
a = txs[:inp]
print(":inp=:", inp)
print("gt:input number =", tts[:inp])
x = txs[:inp].reshape((-1, 28, 28, 1))
hook = UserHook()
output = style_prefix if args.output == None else args.output
fs = os.listdir(args.dataset)
imagepaths = []
for fn in fs:
base, ext = os.path.splitext(fn)
if ext == '.jpg' or ext == '.png':
imagepath = os.path.join(args.dataset, fn)
imagepaths.append(imagepath)
n_data = len(imagepaths)
print('num traning images:', n_data)
n_iter = n_data // batchsize
print(n_iter, 'iterations,', n_epoch, 'epochs')
model = FastStyleNet()
vgg = VGG()
serializers.load_npz('vgg16.model', vgg)
if args.initmodel:
print('load model from', args.initmodel)
serializers.load_npz(args.initmodel, model)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
model.to_gpu()
vgg.to_gpu()
xp = np if args.gpu < 0 else cuda.cupy
O = optimizers.Adam(alpha=args.lr)
O.setup(model)
if args.resume:
print('load optimizer state from', args.resume)
serializers.load_npz(args.resume, O)
xp = np
if args.gpu > 0:
cuda.check_cuda_available()
cuda.get_device(args.gpu).use()
model.to_gpu()
xp = np if args.gpu <= 0 else cuda.cupy #args.gpu <= 0: use cpu, otherwise: use gpu
batchsize = args.batchsize
n_epoch = args.epoch
# Setup optimizer
optimizer = optimizers.AdaGrad()
optimizer.setup(model)
# " model,optimizerに読み込む
serializers.load_npz('./model/pn_classifier_cnn.model', model)
serializers.load_npz('./model/pn_classifier_cnn.state', optimizer)
# evaluation
sum_test_loss = 0.0
sum_test_accuracy = 0.0
print('fN_test ', N_test )
print('batchsize ', batchsize)
for i in six.moves.range(0, N_test, batchsize):
# all test data
x = chainer.Variable(xp.asarray(x_test[i:i + batchsize]))
t = chainer.Variable(xp.asarray(y_test[i:i + batchsize]))
loss = model(x, t)
tmp = 'union'
with open('{0}/args/domain-{1}_case-{2}.json'.format(args.dir, tmp,
case)) as f:
tmp = json.load(f)
for key in tmp.keys():
args.__dict__[key] = tmp[key]
feature_size = test_data[0][0].shape[1]
model = BiLSTMBase(input_size=feature_size,
output_size=feature_size,
n_labels=2,
n_layers=args.n_layers,
dropout=args.dropout,
type_statistics_dict=type_statistics_dict)
serializers.load_npz(model_path, model)
correct_num = {
'all': 0.,
'照応なし': 0.,
'文内': 0.,
'文内(dep)': 0.,
'文内(zero)': 0.,
'発信者': 0.,
'受信者': 0.,
'項不定': 0.
}
case_num = {
'all': 0.,
'照応なし': 0.,
'文内': 0.,
'文内(dep)': 0.,
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--model', '-m', type=str, default=None)
parser.add_argument('--batch', '-b', type=int, default=128)
parser.add_argument('--epoch', '-e', type=int, default=100)
parser.add_argument('--ndata', '-nd', type=int, default=60000,
help='The number of analysis trials (<=60000).')
parser.add_argument('--time', '-t', type=int, default=10,
help='Total simulation time steps.')
parser.add_argument('--dt', '-dt', type=float, default=1e-3,
help='Simulation time step size (sec).')
parser.add_argument('--freq', '-f', type=float, default=100,
help='Input signal maximum frequency (Hz).')
parser.add_argument('--lr', '-l', type=float, default=1e-4)
parser.add_argument('--noplot', dest='plot', action='store_false',
help='Disable PlotReport extension')
args = parser.parse_args()
print("Loading datas")
dataset = LoadDataset(N=args.ndata, dt=args.dt,
num_time=args.time, max_fr=args.freq)
#plt.imshow(np.reshape(dataset[1][0][:, 0], (28, 28)))
#plt.show()
val_rate = 0.2
split_at = int(len(dataset) * (1-val_rate))
train, val = chainer.datasets.split_dataset(dataset, split_at)
train_iter = iterators.SerialIterator(train, batch_size=args.batch, shuffle=True)
test_iter = iterators.SerialIterator(val, batch_size=args.batch, repeat=False, shuffle=False)
chainer.global_config.autotune = True
# Set up a neural network to train.
print("Building model")
if args.gpu >= 0:
# Make a specified GPU current
model = network.SNU_Network(n_in=784, n_mid=256, n_out=10,
num_time=args.time, gpu=True)
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
else:
model = network.SNU_Network(n_in=784, n_mid=256, n_out=10,
num_time=args.time, gpu=False)
optimizer = optimizers.Adam(alpha=args.lr)
#optimizer = optimizers.SGD(lr=args.lr)
#optimizer = optimizers.RMSprop(lr=args.lr, alpha=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(1e-4))
if args.model != None:
print( "loading model from " + args.model)
serializers.load_npz(args.model, model)
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out='results')
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
trainer.extend(extensions.LogReport(trigger=(100, 'iteration')))
# Snapshot
trainer.extend(extensions.snapshot_object(model, 'model_snapshot_{.updater.epoch}'),
trigger=(1,'epoch'))
trainer.extend(extensions.ExponentialShift('alpha', 0.5),trigger=(5, 'epoch'))
# Save two plot images to the result dir
if args.plot and extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch', file_name='loss.png'), trigger=(1, 'epoch'))
trainer.extend(
extensions.PlotReport(
['main/accuracy', 'validation/main/accuracy'],
'epoch', file_name='accuracy.png'), trigger=(1, 'epoch'))
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time']), trigger=(1, 'iteration'))
trainer.extend(extensions.ProgressBar(update_interval=1))
# Train
trainer.run()
# Save results
print("Optimization Finished!")
modelname = "./results/model"
print( "Saving model to " + modelname)
serializers.save_npz(modelname, model)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--epoch', '-e', type=int, default=10,
help='Number of examples in epoch')
parser.add_argument('--batchsize', '-b', type=int, default=1,
help='Number of examples in each mini-batch')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
parser.add_argument('--model', '-m', default='',
help='Load model')
parser.add_argument('--path0', '-p0', default='./DATA/*/*.png',
help='path for images used subject')
parser.add_argument('--path1', '-p1', default='./DATA/*/*.JPEG',
help='path for images used back')
parser.add_argument('--test', '-t', action='store_true',
help='evaluation only')
parser.add_argument('--image', action='store_true',
help='put image for test')
args = parser.parse_args()
train_dataset = DataSet(420, args.path0, args.path1)
test_dataset = DataSet(50, args.path0, args.path1)
model = Loss_Link(VGG())
if args.gpu >= 0:
cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
optimizer = optimizers.Adam()
optimizer.setup(model)
model.predictor.base.disable_update()
if args.model:
serializers.load_npz(args.model, model)
train_iter = iterators.SerialIterator(
train_dataset, batch_size=args.batchsize, shuffle=True)
test_iter = iterators.SerialIterator(
test_dataset, batch_size=args.batchsize, repeat=False)
if args.test:
eva = training.extensions.Evaluator(
test_iter, model, device=args.gpu)()
for key in eva:
print(key + ":" + str(eva[key]))
elif args.image:
if not os.path.exists(args.out):
os.mkdir(args.out)
IMG_PATHS = [args.path0, args.path1]
data = []
base_n = len(glob.glob(IMG_PATHS[1]))
img_n = len(glob.glob(IMG_PATHS[0]))
for i, IMG_PATH in enumerate(IMG_PATHS):
data.append([])
for path in glob.glob(IMG_PATH):
img_ = cv2.imread(path)
if i == 0:
img = cv2.resize(img_, (256, 256))
else:
img = cv2.resize(img_, (512, 512))
data[i].append(img)
offset_x = random.randint(0, 255)
offset_y = random.randint(0, 255)
base = copy.deepcopy(data[1][random.randint(0, base_n - 1)])
base[offset_x:offset_x + 256, offset_y:offset_y +
256, :] = copy.deepcopy(data[0][random.randint(0, img_n - 1)])
cv2.imwrite(args.out + "/input_image.png",
cv2.resize(base, (224, 224)))
mask = np.zeros((512, 512))
mask[offset_x:offset_x + 256, offset_y:offset_y + 256] =\
np.ones((256, 256))
cv2.imwrite(args.out + "/ideal_image.png",
cv2.resize(np.array(mask * 255).
astype("uint8"), (224, 224)))
pred = model.predictor(xp.array([cv2.resize(base, (224, 224)).
transpose(2, 0, 1) / 255]).
astype('float32')).array[0] > 0.7
cv2.imwrite(args.out + "/output_image.png",
np.array(pred * 255).reshape(224, 224).astype("uint8"))
else:
updater = training.StandardUpdater(train_iter, optimizer)
trainer = training.Trainer(
updater, (args.epoch, 'epoch'), out=args.out)
trainer.extend(training.extensions.Evaluator(
test_iter, model, device=args.gpu),
trigger=(1, 'epoch'))
trainer.extend(training.extensions.LogReport(
trigger=(1, 'epoch')))
trainer.extend(training.extensions.PrintReport(
entries=['iteration', 'main/loss',
'main/accuracy', 'elapsed_time']),
trigger=(1, 'epoch'))
trainer.extend(training.extensions.snapshot(),
trigger=((1, 'epoch')))
if args.resume:
serializers.load_npz(args.resume, trainer, strict=False)
trainer.run()
serializers.save_npz('model.npz', model)
def __init__(self, agent_name):
# myname
self.myname = agent_name
self.infer_net = MLP()
serializers.load_npz(os.path.dirname(__file__)+'/snapshot_epoch-2', \
self.infer_net, path='updater/model:main/predictor/')
dir_index = pickle.load(f)
lemma_index = pickle_load('work/glove_index.dump')
lemma_embed = np.load('work/glove50.npy')
n_lemma = len(lemma_index)
# path
counts = pickle_load('unsp_target_path_count.dump')
target_path = pickle_load('unsp_target_path.dump')
model = Unsp_Model(n_lemma_vocab=n_lemma,
n_emb_size=50,
n_units=100,
counts=counts,
init_embed=lemma_embed)
serializers.load_npz(args.unsp_model, model)
for sets in ['/BLESS', '/ROOT09', '/EVALution', '/KHN']:
data_path = args.data_folder + sets
train = data_path + '/train_data.dump'
test = data_path + '/test_data.dump'
val = data_path + '/val_data.dump'
# data augmentation
with open(train, 'rb') as f:
train_data = pickle.load(f)
augmented_train_data = data_aug(model, train_data, args.add_sample,
target_path, lemma_index, pos_index,
dep_index, dir_index)
with open(test, 'rb') as f:
mnist.data /= 255 # 0-1のデータに変換
# mnist.target : 正解データ(教師データ)
mnist.target = mnist.target.astype(np.int32)
n_units = 1000
N = 60000
x_train, x_test = np.split(mnist.data, [N])
y_train, y_test = np.split(mnist.target, [N])
N_test = y_test.size
model = FunctionSet(l1=F.Linear(784, n_units),
l2=F.Linear(n_units, n_units),
l3=F.Linear(n_units, 10))
serializers.load_npz("mnist_model.npz", model)
# 答え合わせ
plt.style.use('fivethirtyeight')
plt.figure(figsize=(15, 15))
cnt = 0
for idx in np.random.permutation(N)[:100]:
xxx = x_train[idx].astype(np.float32)
h1 = F.dropout(F.relu(model.l1(Variable(xxx.reshape(1, 784)))),
train=False)
h2 = F.dropout(F.relu(model.l2(h1)), train=False)
y = model.l3(h2)
cnt += 1
draw_digit3(x_train[idx], cnt, y_train[idx], np.argmax(y.data))
plt.show()
if __name__ == '__main__':
np.random.seed(1412)
dev = 1
with tf.device('/gpu:%d' % dev):
model = load_network(dev=dev)
# data
with open('data_sub1_4096.dat', 'rb') as fp:
_, _, X_test, T_test = pickle.load(fp)
# predict latents
with cupy.cuda.Device(dev):
model_linear = ModelLinear(n_in=4096, n_out=512).to_gpu(dev)
serializers.load_npz('l0_s1_5000_final.model', model_linear)
X_test = cupy.array(X_test, dtype=cupy.float32)
T_test = cupy.array(T_test, dtype=cupy.float32)
Y_test = model_linear(X_test).array
# generate stimuli and reconstructions
face_from_latent(model, cupy.asnumpy(T_test), 'stimuli', save_image=True)
face_from_latent(model, cupy.asnumpy(Y_test), 'reconstructions', save_image=True)
# stimuli vs. reconstructions
trials = len(T_test)
metrics = {"lsim": np.zeros((trials, )),
"fsim": np.zeros((trials, )),
"ssim": np.zeros((trials, )),
"gender": np.zeros((trials, )),
"age": np.zeros((trials, )),
if image.endswith('.jpg') or image.endswith('.png'):
img = cv2.imread(base_dir + image)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img = cv2.resize(img, (img_x, img_y), interpolation=cv2.INTER_AREA)
img_gs = img.flatten()
# print('img _gs len = %d' % len(img_gs))
x_train_data.append(img_gs)
# t_train_data.append(img_gs)
total_datacount = len(x_train_data)
x_train = np.array(x_train_data, dtype=np.float32)
x_train /= 255
print('x_train len = %d' % len(x_train))
x_train_data = None
# Learned data
enc_model_data_file = './enc_model6.npz'
enc = AutoEnc6()
serializers.load_npz(enc_model_data_file, enc)
chainer.config.train = False
x = Variable(x_train)
y = enc.enc(x)
chainer.config.train = False
out_genimages(output_dir, output_base, y, enc)
def experiment1(settings):
experiment_name = settings['experiment_name']
word2vec = settings['word2vec']
num_N_train = settings['num_N_train']
n_argument = settings['n_argument']
batchsize = settings['batchsize']
epoch = settings['epoch']
alpha = settings['alpha']
datasets = settings['datasets']
path_dataset = settings['path_dataset']
n_attribute = settings['n_attribute']
num_N_test = settings['num_N_test']
n_top = settings['n_top']
gpu = settings['gpu']
net = copy.deepcopy(settings['model']['net'])
Updater = copy.deepcopy(settings['updater']['updater'])
out = settings['out']
resume = settings['resume']
snapshot_interval = settings['snapshot_interval']
display_interval = settings['display_interval']
emb_method = settings['embedding_method'] # word2vec, glove
# Load data
_xs_train, xs_val, xs_test, _ts_train, ts_val, ts_test, _zs_train, \
zs_val, zs_test, M, F, xs, ts, zs, A_train, A_val, A_test, z_ids, \
N_train = data_loader.load_datasets(datasets, word2vec, num_N_train, path_dataset, emb_method)
# Data argumention
xs_train = data_loader.data_argument(_xs_train, n_argument)
ts_train = data_loader.data_argument(_ts_train, n_argument)
zs_train = data_loader.data_argument(_zs_train, n_argument)
#xs_train = _xs_train
#ts_train = _ts_train
#zs_train = _zs_train
# Train
if settings['post_process']['train']:
train(net,
Updater,
word2vec,
batchsize,
epoch,
xs_train,
ts_train,
zs_train,
xs_val,
ts_val,
zs_val,
out,
snapshot_interval,
display_interval,
resume=resume,
alpha=alpha,
gpu=gpu)
else: # Evaluation only
settings['experiment_name'] = resume.split('/')[-2]
settings['out'] = resume
out = settings['out']
# Get a best model
if settings['post_process']['best_model']:
print('\nSearching best model...')
max_ittr = epoch * (len(xs_train)//batchsize)
#best = get_best_model_by_accuracy(settings, max_ittr, xs_val, ts_val, zs_val, word2vec, out, snapshot_interval)
best = get_best_model_by_accuracy(settings, max_ittr, xs_val, ts_val, zs_val, word2vec, out, snapshot_interval)
net = copy.deepcopy(settings['model']['net'])
best_path = '{}/net_iter_{}.npz'.format(out, best['ittr'])
#best_path = '{}/{}'
serializers.load_npz(best_path, net)
else:
best = ''
# Evaluation (Accuracy)
if settings['post_process']['acc']:
print('\ncalculating accuracies...')
train_results = {}
val_results = {}
test_results = {}
for z_id in set(zs):
print('\tz: ', z_ids[str(z_id)])
train_results[str(z_id)] = evals.evaluation1_acc(A_train[z_id]['xs'], A_train[z_id]['ts'], \
A_train[z_id]['zs'], net, word2vec, n_top, 'train')
val_results[str(z_id)] = evals.evaluation1_acc(A_val[z_id]['xs'], A_val[z_id]['ts'], \
A_val[z_id]['zs'], net, word2vec, n_top, 'val')
test_results[str(z_id)] = evals.evaluation1_acc(A_test[z_id]['xs'], A_test[z_id]['ts'], \
A_test[z_id]['zs'], net, word2vec, n_top, 'test')
else:
train_results, val_results, test_results = '', '', ''
# Evaluation (Stability)
if settings['post_process']['stb']:
print('\ncalculating stability score...')
stb_results = {}
for z_id in set(zs):
print('\tz: ', z_ids[str(z_id)])
stb_results[str(z_id)] = evals.evaluation1_stb(net, z_id, word2vec, M, F, num_N_test, n_top)
else:
stb_results = ''
# Save results
if settings['post_process']['save_results']:
print('\nsaving results and experimental settings...')
del settings['word2vec']
del settings['model']['net']
del settings['updater']['updater']
results = {}
results['experimental_settings'] = settings
results['net'] = {'best':best_path,
'history':best}
results['accuracy'] = {'train':train_results,
'val':val_results,
'test':test_results}
results['stability'] = {'score':stb_results,
'num_N_test':{'size':num_N_test,
'data':stb_results[str(0)]['x']},
'num_N_train':{'size':num_N_train,
'data':N_train}}
path_save = '{}/evaluation_results'.format('/'.join(out.split('/')[:-1]))
os.makedirs(path_save, exist_ok=True)
with open('{}/evaluation_results.json'.format(path_save), 'w') as f:
json.dump(results, f)
print('done.')
def load_model(modelFile):
chaSerial.load_npz(modelFile, model)
return model
def main():
parser = argparse.ArgumentParser(description='Chainer example: seq2seq')
parser.add_argument('--SOURCE',
default="./dataset/train.en",
help='source sentence list')
parser.add_argument('--TARGET',
default="./dataset/train.jp",
help='target sentence list')
parser.add_argument('--SOURCE_VOCAB',
default="./dataset/vocab.en",
help='source vocabulary file')
parser.add_argument('--TARGET_VOCAB',
default="./dataset/vocab.jp",
help='target vocabulary file')
parser.add_argument('--validation-source',
default="./dataset/test.en",
help='source sentence list for validation')
parser.add_argument('--validation-target',
default="./dataset/test.jp",
help='target sentence list for validation')
parser.add_argument('--batchsize',
'-b',
type=int,
default=48,
help='number of sentence pairs in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=200,
help='number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=0,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--resume',
'-r',
default='',
help='resume the training from snapshot')
parser.add_argument('--unit',
'-u',
type=int,
default=300,
help='number of units')
parser.add_argument('--layer',
'-l',
type=int,
default=3,
help='number of layers')
parser.add_argument('--min-source-sentence',
type=int,
default=1,
help='minimium length of source sentence')
parser.add_argument('--max-source-sentence',
type=int,
default=50,
help='maximum length of source sentence')
parser.add_argument('--min-target-sentence',
type=int,
default=1,
help='minimium length of target sentence')
parser.add_argument('--max-target-sentence',
type=int,
default=50,
help='maximum length of target sentence')
parser.add_argument('--log-interval',
type=int,
default=200,
help='number of iteration to show log')
parser.add_argument('--validation-interval',
type=int,
default=4000,
help='number of iteration to evlauate the model '
'with validation dataset')
parser.add_argument('--out',
'-o',
default='result',
help='directory to output the result')
parser.add_argument('--start',
'-s',
default=0,
help='start test from this column')
parser.add_argument('--model',
'-m',
default='./result/300-200/snapshot_epoch-200',
help='model name to validate')
args = parser.parse_args()
source_ids = load_vocabulary(
args.SOURCE_VOCAB) # dict {a:11, the:3, ...} word_to_id
target_ids = load_vocabulary(args.TARGET_VOCAB)
target_words = {i: w
for w, i in target_ids.items()
} # dict {11:a, 3:the, ...} id_to_wod
source_words = {i: w for w, i in source_ids.items()}
model = Seq2seq(args.layer, len(source_ids), len(target_ids), args.unit,
args.batchsize)
serializers.load_npz('./result/300-200/snapshot_epoch-200',
model,
path='updater/model:main/')
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu(args.gpu)
if args.validation_source and args.validation_target:
test_source = load_data(source_ids, args.validation_source)
test_target = load_data(target_ids, args.validation_target)
assert len(test_source) == len(test_target)
test_data = list(six.moves.zip(test_source, test_target))
test_data = [(s, t) for s, t in test_data if 0 < len(s) and 0 < len(t)]
test_source_unknown = calculate_unknown_ratio(
[s for s, _ in test_data])
test_target_unknown = calculate_unknown_ratio(
[t for _, t in test_data])
print('Validation data: %d' % len(test_data))
print('Validation source unknown ratio: %.2f%%' %
(test_source_unknown * 100))
print('Validation target unknown ratio: %.2f%%' %
(test_target_unknown * 100))
test = test_data[args.start:args.start + args.batchsize]
source = [cuda.cupy.asarray(s) for s, _ in test
] # [[sentence1], [sentence2], [sentence3], ...]
target = [cuda.cupy.asarray(t) for _, t in test]
result = model.translate(source)
with open("./translate.txt", "w") as f:
for b in range(args.batchsize):
source_sentence = ' '.join(
[source_words[int(x)] for x in source[b]])
target_sentence = ' '.join(
[target_words[int(y)] for y in target[b]])
result_sentence = ' '.join(
[target_words[int(y)] for y in result[b]])
f.write('# source[{0}] : {1}{2}'.format(
b, source_sentence, '\n'))
f.write('# result[{0}] : {1}{2}'.format(
b, result_sentence, '\n'))
f.write('# expect[{0}] : {1}{2}'.format(
b, target_sentence, '\n'))
f.write('\n')
f.write('\n')
X_varid[i, idx_list] = 1
Y_varid = np.zeros((len(Y_varid_idx), len(output_w2i)), dtype=np.float32)
for i, idx_list in enumerate(Y_varid_idx):
Y_varid[i, idx_list] = 1
# sys.stdout.write("length of train data: {}\n".format(len(Y_train_idx)))
sys.stdout.write("length of varid data: {}\n".format(len(Y_varid_idx)))
sys.stdout.write("dimension of input vector: {}\n".format(len(X_varid[0])))
sys.stdout.write("dimension of output vector: {}\n".format(len(
Y_varid[0])))
sys.stdout.write("dimension of input w2i dict: {}\n".format(
len(input_w2i)))
sys.stdout.write("dimension of output w2i dict: {}\n".format(
len(output_w2i)))
Y_varid_rav = np.ravel(Y_varid)
chaSerial.load_npz(args.modelName, model)
step = 10
for th in [float(t) / step for t in range(step)]:
pred_vec = model.fwd(Variable(X_varid)).data
hyp_vec = pred_vec.copy()
for i in range(len(hyp_vec)):
hyp_vec[i, pred_vec[i] >= th] = 1.0
hyp_vec[i, pred_vec[i] < th] = 0.0
# precision, recall, fscore, tmp = precision_recall_fscore_support(np.ravel(Y_varid), np.ravel(hyp_vec))
hyp_vec_rav = np.ravel(hyp_vec)
precision = metrics.precision_score(Y_varid_rav, hyp_vec_rav)
recall = metrics.recall_score(Y_varid_rav, hyp_vec_rav)
fscore = metrics.f1_score(Y_varid_rav, hyp_vec_rav)
print("orig {}\t{}\t{}\t{}".format(th, precision, recall, fscore))
# 正解にあって正答していないインデックスをdiffとして、そこからランダムにとってきて１にする
def get_fastseresnet(blocks,
bottleneck=None,
conv1_stride=True,
model_name=None,
pretrained=False,
root=os.path.join("~", ".chainer", "models"),
**kwargs):
"""
Create Fast-SE-ResNet model with specific parameters.
Parameters:
----------
blocks : int
Number of blocks.
bottleneck : bool, default None
Whether to use a bottleneck or simple block in units.
conv1_stride : bool, default True
Whether to use stride in the first or the second convolution layer in units.
model_name : str or None, default None
Model name for loading pretrained model.
pretrained : bool, default False
Whether to load the pretrained weights for model.
root : str, default '~/.chainer/models'
Location for keeping the model parameters.
"""
if bottleneck is None:
bottleneck = (blocks >= 50)
if blocks == 10:
layers = [1, 1, 1, 1]
elif blocks == 12:
layers = [2, 1, 1, 1]
elif blocks == 14 and not bottleneck:
layers = [2, 2, 1, 1]
elif (blocks == 14) and bottleneck:
layers = [1, 1, 1, 1]
elif blocks == 16:
layers = [2, 2, 2, 1]
elif blocks == 18:
layers = [2, 2, 2, 2]
elif (blocks == 26) and not bottleneck:
layers = [3, 3, 3, 3]
elif (blocks == 26) and bottleneck:
layers = [2, 2, 2, 2]
elif blocks == 34:
layers = [3, 4, 6, 3]
elif (blocks == 38) and bottleneck:
layers = [3, 3, 3, 3]
elif blocks == 50:
layers = [3, 4, 6, 3]
elif blocks == 101:
layers = [3, 4, 23, 3]
elif blocks == 152:
layers = [3, 8, 36, 3]
elif blocks == 200:
layers = [3, 24, 36, 3]
else:
raise ValueError(
"Unsupported Fast-SE-ResNet with number of blocks: {}".format(
blocks))
if bottleneck:
assert (sum(layers) * 3 + 2 == blocks)
else:
assert (sum(layers) * 2 + 2 == blocks)
init_block_channels = 64
channels_per_layers = [64, 128, 256, 512]
if bottleneck:
bottleneck_factor = 4
channels_per_layers = [
ci * bottleneck_factor for ci in channels_per_layers
]
channels = [[ci] * li for (ci, li) in zip(channels_per_layers, layers)]
net = FastSEResNet(channels=channels,
init_block_channels=init_block_channels,
bottleneck=bottleneck,
conv1_stride=conv1_stride,
**kwargs)
if pretrained:
if (model_name is None) or (not model_name):
raise ValueError(
"Parameter `model_name` should be properly initialized for loading pretrained model."
)
from .model_store import get_model_file
load_npz(file=get_model_file(model_name=model_name,
local_model_store_dir_path=root),
obj=net)
return net
if cv.waitKey(1) & 0xFF == ord('q'):
break
cv.destroyAllWindows()
# In[]
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--pretrained-model', default='voc07')
parser.add_argument('video')
args = parser.parse_args()
if args.pretrained_model == 'trained_model_cpu':
#model = L.Classifier(Mynet.MyNet(100))
model = L.Classifier(VGG_chainer.VGG(5))
serializers.load_npz('trained_model_cpu', model)
print('VGG is defined')
else:
model = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names),
pretrained_model=args.pretrained_model)
if args.gpu >= 0:
model.to_gpu(args.gpu)
print('gpu is defined')
# model = L.Classifier(VGG_chainer.VGG(100))
# serializers.load_npz('trained_model',model)
# print('VGG is defined')
# data_path = "./cifar-100-python"
# test_data, test_clabels, test_flabels, clabels,flabels = get_cifar100(data_path)
flabels = ['bicycle', 'motorcycle', 'train', 'automobile', 'person']
diff_frame(args.video, model, flabels)
def main(args):
####################
# Arguments
gpu = args.gpu
model_name = args.model
initial_tree_sampling = args.initial_tree_sampling
path_config = args.config
data_augmentation = args.data_augmentation
trial_name = args.name
actiontype = args.actiontype
max_epoch = args.max_epoch
dev_size = args.dev_size
# Check
assert actiontype in ["train", "evaluate"]
if actiontype == "train":
assert max_epoch > 0
assert len(initial_tree_sampling.split("_")) == 3
for type_ in initial_tree_sampling.split("_"):
assert type_ in ["X", "BU", "TD", "RB", "LB", "RB2"]
assert initial_tree_sampling.split("_")[2] != "X"
assert initial_tree_sampling.split("_")[1] != "RB2"
assert initial_tree_sampling.split("_")[2] != "RB2"
if trial_name is None or trial_name == "None":
trial_name = utils.get_current_time()
####################
# Path setting
config = utils.Config(path_config)
basename = "%s.%s.%s.aug_%s.%s" \
% (model_name,
initial_tree_sampling,
utils.get_basename_without_ext(path_config),
data_augmentation,
trial_name)
if actiontype == "train":
path_log = os.path.join(config.getpath("results"),
basename + ".training.log")
elif actiontype == "evaluate":
path_log = os.path.join(config.getpath("results"),
basename + ".evaluation.log")
path_train = os.path.join(config.getpath("results"),
basename + ".training.jsonl")
path_valid = os.path.join(config.getpath("results"),
basename + ".validation.jsonl")
path_snapshot = os.path.join(config.getpath("results"),
basename + ".model")
path_pred = os.path.join(config.getpath("results"),
basename + ".evaluation.ctrees")
path_eval = os.path.join(config.getpath("results"),
basename + ".evaluation.json")
utils.set_logger(path_log)
####################
# Random seed
random_seed = trial_name
random_seed = utils.hash_string(random_seed)
random.seed(random_seed)
np.random.seed(random_seed)
cuda.cupy.random.seed(random_seed)
####################
# Log so far
utils.writelog("gpu=%d" % gpu)
utils.writelog("model_name=%s" % model_name)
utils.writelog("initial_tree_sampling=%s" % initial_tree_sampling)
utils.writelog("path_config=%s" % path_config)
utils.writelog("data_augmentation=%s" % data_augmentation)
utils.writelog("trial_name=%s" % trial_name)
utils.writelog("actiontype=%s" % actiontype)
utils.writelog("max_epoch=%s" % max_epoch)
utils.writelog("dev_size=%s" % dev_size)
utils.writelog("path_log=%s" % path_log)
utils.writelog("path_train=%s" % path_train)
utils.writelog("path_valid=%s" % path_valid)
utils.writelog("path_snapshot=%s" % path_snapshot)
utils.writelog("path_pred=%s" % path_pred)
utils.writelog("path_eval=%s" % path_eval)
utils.writelog("random_seed=%d" % random_seed)
####################
# Data preparation
begin_time = time.time()
train_databatch = dataloader.read_rstdt("train",
relation_level="coarse-grained",
with_root=False)
test_databatch = dataloader.read_rstdt("test",
relation_level="coarse-grained",
with_root=False)
vocab_word = utils.read_vocab(
os.path.join(config.getpath("data"), "rstdt-vocab", "words.vocab.txt"))
vocab_postag = utils.read_vocab(
os.path.join(config.getpath("data"), "rstdt-vocab",
"postags.vocab.txt"))
vocab_deprel = utils.read_vocab(
os.path.join(config.getpath("data"), "rstdt-vocab",
"deprels.vocab.txt"))
if data_augmentation:
external_train_databatch = dataloader.read_ptbwsj_wo_rstdt(
with_root=False)
# Remove documents with only one leaf node
filtering_function = lambda d, i: len(d.batch_edu_ids[i]) == 1
external_train_databatch = utils.filter_databatch(
external_train_databatch, filtering_function)
end_time = time.time()
utils.writelog("Loaded the corpus. %f [sec.]" % (end_time - begin_time))
####################
# Hyper parameters
word_dim = config.getint("word_dim")
postag_dim = config.getint("postag_dim")
deprel_dim = config.getint("deprel_dim")
lstm_dim = config.getint("lstm_dim")
mlp_dim = config.getint("mlp_dim")
n_init_epochs = config.getint("n_init_epochs")
negative_size = config.getint("negative_size")
batch_size = config.getint("batch_size")
weight_decay = config.getfloat("weight_decay")
gradient_clipping = config.getfloat("gradient_clipping")
optimizer_name = config.getstr("optimizer_name")
utils.writelog("word_dim=%d" % word_dim)
utils.writelog("postag_dim=%d" % postag_dim)
utils.writelog("deprel_dim=%d" % deprel_dim)
utils.writelog("lstm_dim=%d" % lstm_dim)
utils.writelog("mlp_dim=%d" % mlp_dim)
utils.writelog("n_init_epochs=%d" % n_init_epochs)
utils.writelog("negative_size=%d" % negative_size)
utils.writelog("batch_size=%d" % batch_size)
utils.writelog("weight_decay=%f" % weight_decay)
utils.writelog("gradient_clipping=%f" % gradient_clipping)
utils.writelog("optimizer_name=%s" % optimizer_name)
####################
# Model preparation
cuda.get_device(gpu).use()
# Initialize a model
utils.mkdir(os.path.join(config.getpath("data"), "caches"))
path_embed = config.getpath("pretrained_word_embeddings")
path_caches = os.path.join(
config.getpath("data"), "caches",
"cached." + os.path.basename(path_embed) + ".npy")
if os.path.exists(path_caches):
utils.writelog("Loading cached word embeddings ...")
initialW = np.load(path_caches)
else:
initialW = utils.read_word_embedding_matrix(path=path_embed,
dim=word_dim,
vocab=vocab_word,
scale=0.0)
np.save(path_caches, initialW)
if model_name == "spanbasedmodel":
# Span-based model w/ template features
template_feature_extractor = models.TemplateFeatureExtractor(
databatch=train_databatch)
utils.writelog("Template feature size=%d" %
template_feature_extractor.feature_size)
if actiontype == "train":
for template in template_feature_extractor.templates:
dim = template_feature_extractor.template2dim[template]
utils.writelog("Template feature #%s %s" % (dim, template))
model = models.SpanBasedModel(
vocab_word=vocab_word,
vocab_postag=vocab_postag,
vocab_deprel=vocab_deprel,
word_dim=word_dim,
postag_dim=postag_dim,
deprel_dim=deprel_dim,
lstm_dim=lstm_dim,
mlp_dim=mlp_dim,
initialW=initialW,
template_feature_extractor=template_feature_extractor)
elif model_name == "spanbasedmodel2":
# Span-based model w/o template features
model = models.SpanBasedModel2(vocab_word=vocab_word,
vocab_postag=vocab_postag,
vocab_deprel=vocab_deprel,
word_dim=word_dim,
postag_dim=postag_dim,
deprel_dim=deprel_dim,
lstm_dim=lstm_dim,
mlp_dim=mlp_dim,
initialW=initialW)
else:
raise ValueError("Invalid model_name=%s" % model_name)
utils.writelog("Initialized the model ``%s''" % model_name)
# Load pre-trained parameters
if actiontype != "train":
serializers.load_npz(path_snapshot, model)
utils.writelog("Loaded trained parameters from %s" % path_snapshot)
model.to_gpu(gpu)
####################
# Decoder preparation
decoder = decoders.IncrementalCKYDecoder()
####################
# Initializer preparation
sampler = treesamplers.TreeSampler(initial_tree_sampling.split("_"))
####################
# Training / evaluation
if actiontype == "train":
with chainer.using_config("train", True):
if dev_size > 0:
# Training with cross validation
train_databatch, dev_databatch = dataloader.randomsplit(
n_dev=dev_size, databatch=train_databatch)
with open(
os.path.join(config.getpath("results"),
basename + ".valid_gold.ctrees"),
"w") as f:
for sexp in dev_databatch.batch_nary_sexp:
f.write("%s\n" % " ".join(sexp))
else:
# Training with the full training set
dev_databatch = None
if data_augmentation:
train_databatch = utils.concat_databatch(
train_databatch, external_train_databatch)
training.train(
model=model,
decoder=decoder,
sampler=sampler,
max_epoch=max_epoch,
n_init_epochs=n_init_epochs,
negative_size=negative_size,
batch_size=batch_size,
weight_decay=weight_decay,
gradient_clipping=gradient_clipping,
optimizer_name=optimizer_name,
train_databatch=train_databatch,
dev_databatch=dev_databatch,
path_train=path_train,
path_valid=path_valid,
path_snapshot=path_snapshot,
path_pred=os.path.join(config.getpath("results"),
basename + ".valid_pred.ctrees"),
path_gold=os.path.join(config.getpath("results"),
basename + ".valid_gold.ctrees"))
elif actiontype == "evaluate":
with chainer.using_config("train", False), chainer.no_backprop_mode():
# Test
parsing.parse(model=model,
decoder=decoder,
databatch=test_databatch,
path_pred=path_pred)
scores = rst_parseval.evaluate(
pred_path=path_pred,
gold_path=os.path.join(config.getpath("data"), "rstdt",
"renamed", "test.labeled.nary.ctrees"))
old_scores = old_rst_parseval.evaluate(
pred_path=path_pred,
gold_path=os.path.join(config.getpath("data"), "rstdt",
"renamed", "test.labeled.nary.ctrees"))
out = {
"Morey2018": {
"Unlabeled Precision": scores["S"]["Precision"] * 100.0,
"Precision_info": scores["S"]["Precision_info"],
"Unlabeled Recall": scores["S"]["Recall"] * 100.0,
"Recall_info": scores["S"]["Recall_info"],
"Micro F1": scores["S"]["Micro F1"] * 100.0
},
"Marcu2000": {
"Unlabeled Precision":
old_scores["S"]["Precision"] * 100.0,
"Precision_info": old_scores["S"]["Precision_info"],
"Unlabeled Recall": old_scores["S"]["Recall"] * 100.0,
"Recall_info": old_scores["S"]["Recall_info"],
"Micro F1": old_scores["S"]["Micro F1"] * 100.0
}
}
utils.write_json(path_eval, out)
utils.writelog(utils.pretty_format_dict(out))
utils.writelog("Done: %s" % basename)
def get_resnet(blocks,
conv1_stride=True,
use_se=False,
width_scale=1.0,
model_name=None,
pretrained=False,
root=os.path.join('~', '.chainer', 'models'),
**kwargs):
"""
Create ResNet or SE-ResNet model with specific parameters.
Parameters:
----------
blocks : int
Number of blocks.
conv1_stride : bool
Whether to use stride in the first or the second convolution layer in units.
use_se : bool
Whether to use SE block.
width_scale : float
Scale factor for width of layers.
model_name : str or None, default None
Model name for loading pretrained model.
pretrained : bool, default False
Whether to load the pretrained weights for model.
ctx : Context, default CPU
The context in which to load the pretrained weights.
root : str, default '~/.chainer/models'
Location for keeping the model parameters.
"""
if blocks == 10:
layers = [1, 1, 1, 1]
elif blocks == 12:
layers = [2, 1, 1, 1]
elif blocks == 14:
layers = [2, 2, 1, 1]
elif blocks == 16:
layers = [2, 2, 2, 1]
elif blocks == 18:
layers = [2, 2, 2, 2]
elif blocks == 34:
layers = [3, 4, 6, 3]
elif blocks == 50:
layers = [3, 4, 6, 3]
elif blocks == 101:
layers = [3, 4, 23, 3]
elif blocks == 152:
layers = [3, 8, 36, 3]
elif blocks == 200:
layers = [3, 24, 36, 3]
else:
raise ValueError("Unsupported ResNet with number of blocks: {}".format(blocks))
init_block_channels = 64
if blocks < 50:
channels_per_layers = [64, 128, 256, 512]
bottleneck = False
else:
channels_per_layers = [256, 512, 1024, 2048]
bottleneck = True
channels = [[ci] * li for (ci, li) in zip(channels_per_layers, layers)]
if width_scale != 1.0:
channels = [[int(cij * width_scale) for cij in ci] for ci in channels]
init_block_channels = int(init_block_channels * width_scale)
net = ResNet(
channels=channels,
init_block_channels=init_block_channels,
bottleneck=bottleneck,
conv1_stride=conv1_stride,
use_se=use_se,
**kwargs)
if pretrained:
if (model_name is None) or (not model_name):
raise ValueError("Parameter `model_name` should be properly initialized for loading pretrained model.")
from .model_store import get_model_file
load_npz(
file=get_model_file(
model_name=model_name,
local_model_store_dir_path=root),
obj=net)
return net
def main():
args = arguments()
print(args)
if args.imgtype == "dcm":
from dataset_dicom import Dataset as Dataset
else:
from dataset_jpg import DatasetOutMem as Dataset
# CUDA
if not chainer.cuda.available:
print("CUDA required")
exit()
if len(args.gpu) == 1 and args.gpu[0] >= 0:
chainer.cuda.get_device_from_id(args.gpu[0]).use()
# Enable autotuner of cuDNN
chainer.config.autotune = True
chainer.config.dtype = dtypes[args.dtype]
chainer.print_runtime_info()
# Turn off type check
# chainer.config.type_check = False
# print('Chainer version: ', chainer.__version__)
# print('GPU availability:', chainer.cuda.available)
# print('cuDNN availablility:', chainer.cuda.cudnn_enabled)
## dataset iterator
print("Setting up data iterators...")
train_A_dataset = Dataset(path=os.path.join(args.root, 'trainA'),
args=args,
base=args.HU_baseA,
rang=args.HU_rangeA,
random=args.random_translate)
train_B_dataset = Dataset(path=os.path.join(args.root, 'trainB'),
args=args,
base=args.HU_baseB,
rang=args.HU_rangeB,
random=args.random_translate)
test_A_dataset = Dataset(path=os.path.join(args.root, 'testA'),
args=args,
base=args.HU_baseA,
rang=args.HU_rangeA,
random=0)
test_B_dataset = Dataset(path=os.path.join(args.root, 'testB'),
args=args,
base=args.HU_baseB,
rang=args.HU_rangeB,
random=0)
args.ch = train_A_dataset.ch
args.out_ch = train_B_dataset.ch
print("channels in A {}, channels in B {}".format(args.ch, args.out_ch))
# test_A_iter = chainer.iterators.SerialIterator(test_A_dataset, args.nvis_A, shuffle=False)
# test_B_iter = chainer.iterators.SerialIterator(test_B_dataset, args.nvis_B, shuffle=False)
test_A_iter = chainer.iterators.MultithreadIterator(test_A_dataset,
args.nvis_A,
shuffle=False,
n_threads=3)
test_B_iter = chainer.iterators.MultithreadIterator(test_B_dataset,
args.nvis_B,
shuffle=False,
n_threads=3)
train_A_iter = chainer.iterators.MultithreadIterator(train_A_dataset,
args.batch_size,
n_threads=3)
train_B_iter = chainer.iterators.MultithreadIterator(train_B_dataset,
args.batch_size,
n_threads=3)
# setup models
enc_x = Encoder(args)
enc_y = enc_x if args.single_encoder else Encoder(args)
dec_x = Decoder(args)
dec_y = Decoder(args)
dis_x = Discriminator(args)
dis_y = Discriminator(args)
dis_z = Discriminator(
args) if args.lambda_dis_z > 0 else chainer.links.Linear(1, 1)
models = {
'enc_x': enc_x,
'dec_x': dec_x,
'enc_y': enc_y,
'dec_y': dec_y,
'dis_x': dis_x,
'dis_y': dis_y,
'dis_z': dis_z
}
## load learnt models
if args.load_models:
for e in models:
m = args.load_models.replace('enc_x', e)
try:
serializers.load_npz(m, models[e])
print('model loaded: {}'.format(m))
except:
print("couldn't load {}".format(m))
pass
# select GPU
if len(args.gpu) == 1:
for e in models:
models[e].to_gpu()
print('using gpu {}, cuDNN {}'.format(args.gpu,
chainer.cuda.cudnn_enabled))
else:
print("mandatory GPU use: currently only a single GPU can be used")
exit()
# Setup optimisers
def make_optimizer(model, lr, opttype='Adam'):
# eps = 1e-5 if args.dtype==np.float16 else 1e-8
optimizer = optim[opttype](lr)
#from profiled_optimizer import create_marked_profile_optimizer
# optimizer = create_marked_profile_optimizer(optim[opttype](lr), sync=True, sync_level=2)
optimizer.setup(model)
if args.weight_decay > 0:
if opttype in ['Adam', 'AdaBound', 'Eve']:
optimizer.weight_decay_rate = args.weight_decay
else:
if args.weight_decay_norm == 'l2':
optimizer.add_hook(
chainer.optimizer.WeightDecay(args.weight_decay))
else:
optimizer.add_hook(
chainer.optimizer_hooks.Lasso(args.weight_decay))
return optimizer
opt_enc_x = make_optimizer(enc_x, args.learning_rate_g, args.optimizer)
opt_dec_x = make_optimizer(dec_x, args.learning_rate_g, args.optimizer)
opt_enc_y = make_optimizer(enc_y, args.learning_rate_g, args.optimizer)
opt_dec_y = make_optimizer(dec_y, args.learning_rate_g, args.optimizer)
opt_x = make_optimizer(dis_x, args.learning_rate_d, args.optimizer)
opt_y = make_optimizer(dis_y, args.learning_rate_d, args.optimizer)
opt_z = make_optimizer(dis_z, args.learning_rate_d, args.optimizer)
optimizers = {
'opt_enc_x': opt_enc_x,
'opt_dec_x': opt_dec_x,
'opt_enc_y': opt_enc_y,
'opt_dec_y': opt_dec_y,
'opt_x': opt_x,
'opt_y': opt_y,
'opt_z': opt_z
}
if args.load_optimizer:
for e in optimizers:
try:
m = args.load_models.replace('enc_x', e)
serializers.load_npz(m, optimizers[e])
print('optimiser loaded: {}'.format(m))
except:
print("couldn't load {}".format(m))
pass
# Set up an updater: TODO: multi gpu updater
print("Preparing updater...")
updater = Updater(models=(enc_x, dec_x, enc_y, dec_y, dis_x, dis_y, dis_z),
iterator={
'main': train_A_iter,
'train_B': train_B_iter,
},
optimizer=optimizers,
converter=convert.ConcatWithAsyncTransfer(),
device=args.gpu[0],
params={'args': args})
if args.snapinterval < 0:
args.snapinterval = args.lrdecay_start + args.lrdecay_period
log_interval = (200, 'iteration')
model_save_interval = (args.snapinterval, 'epoch')
plot_interval = (500, 'iteration')
# Set up a trainer
print("Preparing trainer...")
if args.iteration:
stop_trigger = (args.iteration, 'iteration')
else:
stop_trigger = (args.lrdecay_start + args.lrdecay_period, 'epoch')
trainer = training.Trainer(updater, stop_trigger, out=args.out)
for e in models:
trainer.extend(extensions.snapshot_object(models[e],
e + '{.updater.epoch}.npz'),
trigger=model_save_interval)
# trainer.extend(extensions.ParameterStatistics(models[e])) ## very slow
for e in optimizers:
trainer.extend(extensions.snapshot_object(optimizers[e],
e + '{.updater.epoch}.npz'),
trigger=model_save_interval)
log_keys = ['epoch', 'iteration', 'lr']
log_keys_cycle = [
'opt_enc_x/loss_cycle', 'opt_enc_y/loss_cycle', 'opt_dec_x/loss_cycle',
'opt_dec_y/loss_cycle', 'myval/cycle_x_l1', 'myval/cycle_y_l1'
]
log_keys_adv = [
'opt_enc_y/loss_adv', 'opt_dec_y/loss_adv', 'opt_enc_x/loss_adv',
'opt_dec_x/loss_adv'
]
log_keys_d = []
if args.lambda_reg > 0:
log_keys.extend(['opt_enc_x/loss_reg', 'opt_enc_y/loss_reg'])
if args.lambda_tv > 0:
log_keys.extend(['opt_dec_y/loss_tv'])
if args.lambda_air > 0:
log_keys.extend(['opt_dec_x/loss_air', 'opt_dec_y/loss_air'])
if args.lambda_grad > 0:
log_keys.extend(['opt_dec_x/loss_grad', 'opt_dec_y/loss_grad'])
if args.lambda_identity_x > 0: # perceptual
log_keys.extend(['opt_enc_x/loss_id', 'opt_enc_y/loss_id'])
if args.lambda_domain > 0:
log_keys_cycle.extend(['opt_dec_x/loss_dom', 'opt_dec_y/loss_dom'])
if args.dis_reg_weighting > 0:
log_keys_d.extend(
['opt_x/loss_reg', 'opt_y/loss_reg', 'opt_z/loss_reg'])
if args.dis_wgan:
log_keys_d.extend([
'opt_x/loss_dis', 'opt_x/loss_gp', 'opt_y/loss_dis',
'opt_y/loss_gp'
])
if args.lambda_dis_z > 0:
log_keys_d.extend(['opt_z/loss_dis', 'opt_z/loss_gp'])
else:
log_keys_d.extend([
'opt_x/loss_real', 'opt_x/loss_fake', 'opt_y/loss_real',
'opt_y/loss_fake'
])
if args.lambda_dis_z > 0:
log_keys_d.extend(['opt_z/loss_x', 'opt_z/loss_y'])
log_keys_all = log_keys + log_keys_d + log_keys_adv + log_keys_cycle
trainer.extend(
extensions.LogReport(keys=log_keys_all, trigger=log_interval))
trainer.extend(extensions.PrintReport(log_keys_all), trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=20))
trainer.extend(extensions.observe_lr(optimizer_name='opt_enc_x'),
trigger=log_interval)
# learning rate scheduling
decay_start_iter = len(train_A_dataset) * args.lrdecay_start
decay_end_iter = len(train_A_dataset) * (args.lrdecay_start +
args.lrdecay_period)
for e in [opt_enc_x, opt_enc_y, opt_dec_x, opt_dec_y]:
trainer.extend(
extensions.LinearShift('alpha', (args.learning_rate_g, 0),
(decay_start_iter, decay_end_iter),
optimizer=e))
for e in [opt_x, opt_y, opt_z]:
trainer.extend(
extensions.LinearShift('alpha', (args.learning_rate_d, 0),
(decay_start_iter, decay_end_iter),
optimizer=e))
## dump graph
if args.lambda_Az > 0:
trainer.extend(
extensions.dump_graph('opt_enc_x/loss_cycle', out_name='gen.dot'))
if args.lambda_dis_x > 0:
if args.dis_wgan:
trainer.extend(
extensions.dump_graph('opt_x/loss_dis', out_name='dis.dot'))
else:
trainer.extend(
extensions.dump_graph('opt_x/loss_fake', out_name='dis.dot'))
# ChainerUI
trainer.extend(CommandsExtension())
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(log_keys[3:],
'iteration',
trigger=plot_interval,
file_name='loss.png',
postprocess=plot_log))
trainer.extend(
extensions.PlotReport(log_keys_d,
'iteration',
trigger=plot_interval,
file_name='loss_d.png'))
trainer.extend(
extensions.PlotReport(log_keys_adv,
'iteration',
trigger=plot_interval,
file_name='loss_adv.png'))
trainer.extend(
extensions.PlotReport(log_keys_cycle,
'iteration',
trigger=plot_interval,
file_name='loss_cyc.png',
postprocess=plot_log))
## visualisation
vis_folder = os.path.join(args.out, "vis")
os.makedirs(vis_folder, exist_ok=True)
if not args.vis_freq:
args.vis_freq = len(train_A_dataset) // 2
s = [k for k in range(args.num_slices)
] if args.num_slices > 0 and args.imgtype == "dcm" else None
trainer.extend(VisEvaluator({
"testA": test_A_iter,
"testB": test_B_iter
}, {
"enc_x": enc_x,
"enc_y": enc_y,
"dec_x": dec_x,
"dec_y": dec_y
},
params={
'vis_out': vis_folder,
'slice': s,
'args': args
},
device=args.gpu[0]),
trigger=(args.vis_freq, 'iteration'))
## output filenames of training dataset
with open(os.path.join(args.out, 'trainA.txt'), 'w') as output:
for f in train_A_dataset.names:
output.writelines("\n".join(f))
output.writelines("\n")
with open(os.path.join(args.out, 'trainB.txt'), 'w') as output:
for f in train_B_dataset.names:
output.writelines("\n".join(f))
output.writelines("\n")
# archive the scripts
rundir = os.path.dirname(os.path.realpath(__file__))
import zipfile
with zipfile.ZipFile(os.path.join(args.out, 'script.zip'),
'w',
compression=zipfile.ZIP_DEFLATED) as new_zip:
for f in [
'train.py', 'net.py', 'updater.py', 'consts.py', 'losses.py',
'arguments.py', 'convert.py'
]:
new_zip.write(os.path.join(rundir, f), arcname=f)
# Run the training
print("\nresults are saved under: ", args.out)
save_args(args, args.out)
with open(os.path.join(args.out, "args.txt"), 'w') as fh:
fh.write(" ".join(sys.argv))
trainer.run()
def load_model(self, filename='my.model'):
serializers.load_npz(filename, self)
print('Loaded `{}` model.'.format(filename))
A[n_timesteps][n_timesteps - 1] = -2 / dt
A[n_timesteps][n_timesteps - 2] = 1 / dt
for i in range(n_timesteps - 2):
A[i + 2][i] = 1 / dt
A[i + 2][i + 1] = -2 / dt
A[i + 2][i + 2] = 1 / dt
R_inv = np.linalg.inv(np.dot(A.T, A))
M = np.zeros((n_timesteps, n_timesteps))
for i in range(n_timesteps):
M[:, i] = R_inv[:, i] / (n_timesteps * max(R_inv[:, i]))
cinfogan_gen = Generator(62, 12, 6, 70)
serializers.load_npz(
"../training/results/models/cinfogan_models_0/40_gen.model",
cinfogan_gen)
cgan_gen = Generator(62, 12, 6, 70)
serializers.load_npz(
"../training/results/models/cgan_models_0/20_gen.model", cgan_gen)
record_list_ξ = False
verbose = False
data = []
n_experiments = 20
#--- Problem x definition ---#
for i in tqdm(range(n_experiments)):
radius = 0.1
obstacles = np.random.random((3, 2))
wrong_setup = True
def main():
parser = argparse.ArgumentParser(description='training mnist')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--epoch',
'-e',
type=int,
default=300,
help='Number of sweeps over the dataset to train')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='Number of images in each mini-batch')
parser.add_argument('--seed',
'-s',
type=int,
default=0,
help='Random seed')
parser.add_argument('--n_fold',
'-nf',
type=int,
default=5,
help='n_fold cross validation')
parser.add_argument('--fold', '-f', type=int, default=1)
parser.add_argument('--out_dir_name',
'-dn',
type=str,
default=None,
help='Name of the output directory')
parser.add_argument('--report_trigger',
'-rt',
type=str,
default='1e',
help='Interval for reporting(Ex.100i, default:1e)')
parser.add_argument('--save_trigger',
'-st',
type=str,
default='1e',
help='Interval for saving the model'
'(Ex.100i, default:1e)')
parser.add_argument('--load_model',
'-lm',
type=str,
default=None,
help='Path of the model object to load')
parser.add_argument('--load_optimizer',
'-lo',
type=str,
default=None,
help='Path of the optimizer object to load')
args = parser.parse_args()
if args.out_dir_name is None:
start_time = datetime.now()
out_dir = Path('output/{}'.format(start_time.strftime('%Y%m%d_%H%M')))
else:
out_dir = Path('output/{}'.format(args.out_dir_name))
random.seed(args.seed)
np.random.seed(args.seed)
cupy.random.seed(args.seed)
chainer.config.cudnn_deterministic = True
# model = ModifiedClassifier(SEResNeXt50())
# model = ModifiedClassifier(SERes2Net50())
model = ModifiedClassifier(SEResNeXt101())
if args.load_model is not None:
serializers.load_npz(args.load_model, model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
optimizer = optimizers.MomentumSGD(lr=0.1, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(1e-4))
if args.load_optimizer is not None:
serializers.load_npz(args.load_optimizer, optimizer)
n_fold = args.n_fold
slices = [slice(i, None, n_fold) for i in range(n_fold)]
fold = args.fold - 1
# model1
# augmentation = [
# ('Rotate', {'p': 0.8, 'limit': 5}),
# ('PadIfNeeded', {'p': 0.5, 'min_height': 28, 'min_width': 30}),
# ('PadIfNeeded', {'p': 0.5, 'min_height': 30, 'min_width': 28}),
# ('Resize', {'p': 1.0, 'height': 28, 'width': 28}),
# ('RandomScale', {'p': 1.0, 'scale_limit': 0.1}),
# ('PadIfNeeded', {'p': 1.0, 'min_height': 32, 'min_width': 32}),
# ('RandomCrop', {'p': 1.0, 'height': 28, 'width': 28}),
# ('Mixup', {'p': 0.5}),
# ('Cutout', {'p': 0.5, 'num_holes': 4, 'max_h_size': 4,
# 'max_w_size': 4}),
# ]
# resize = None
# model2
augmentation = [
('Rotate', {
'p': 0.8,
'limit': 5
}),
('PadIfNeeded', {
'p': 0.5,
'min_height': 28,
'min_width': 32
}),
('PadIfNeeded', {
'p': 0.5,
'min_height': 32,
'min_width': 28
}),
('Resize', {
'p': 1.0,
'height': 32,
'width': 32
}),
('RandomScale', {
'p': 1.0,
'scale_limit': 0.1
}),
('PadIfNeeded', {
'p': 1.0,
'min_height': 36,
'min_width': 36
}),
('RandomCrop', {
'p': 1.0,
'height': 32,
'width': 32
}),
('Mixup', {
'p': 0.5
}),
('Cutout', {
'p': 0.5,
'num_holes': 4,
'max_h_size': 4,
'max_w_size': 4
}),
]
resize = [('Resize', {'p': 1.0, 'height': 32, 'width': 32})]
train_data = KMNIST(augmentation=augmentation,
drop_index=slices[fold],
pseudo_labeling=True)
valid_data = KMNIST(augmentation=resize, index=slices[fold])
train_iter = iterators.SerialIterator(train_data, args.batchsize)
valid_iter = iterators.SerialIterator(valid_data,
args.batchsize,
repeat=False,
shuffle=False)
updater = StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = Trainer(updater, (args.epoch, 'epoch'), out=out_dir)
report_trigger = (int(args.report_trigger[:-1]), 'iteration'
if args.report_trigger[-1] == 'i' else 'epoch')
trainer.extend(extensions.LogReport(trigger=report_trigger))
trainer.extend(extensions.Evaluator(valid_iter, model, device=args.gpu),
name='val',
trigger=report_trigger)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'main/loss', 'main/accuracy', 'val/main/loss',
'val/main/accuracy', 'elapsed_time'
]),
trigger=report_trigger)
trainer.extend(
extensions.PlotReport(['main/loss', 'val/main/loss'],
x_key=report_trigger[1],
marker='.',
file_name='loss.png',
trigger=report_trigger))
trainer.extend(
extensions.PlotReport(['main/accuracy', 'val/main/accuracy'],
x_key=report_trigger[1],
marker='.',
file_name='accuracy.png',
trigger=report_trigger))
save_trigger = (int(args.save_trigger[:-1]),
'iteration' if args.save_trigger[-1] == 'i' else 'epoch')
trainer.extend(extensions.snapshot_object(
model,
filename='model_{0}-{{.updater.{0}}}.npz'.format(save_trigger[1])),
trigger=save_trigger)
trainer.extend(extensions.snapshot_object(
optimizer,
filename='optimizer_{0}-{{.updater.{0}}}.npz'.format(save_trigger[1])),
trigger=save_trigger)
trainer.extend(extensions.ProgressBar())
trainer.extend(CosineAnnealing(lr_max=0.1, lr_min=1e-6, T_0=20),
trigger=(1, 'epoch'))
best_model_trigger = triggers.MaxValueTrigger('val/main/accuracy',
trigger=(1, 'epoch'))
trainer.extend(extensions.snapshot_object(model,
filename='best_model.npz'),
trigger=best_model_trigger)
trainer.extend(extensions.snapshot_object(optimizer,
filename='best_optimizer.npz'),
trigger=best_model_trigger)
best_loss_model_trigger = triggers.MinValueTrigger('val/main/loss',
trigger=(1, 'epoch'))
trainer.extend(extensions.snapshot_object(model,
filename='best_loss_model.npz'),
trigger=best_loss_model_trigger)
trainer.extend(extensions.snapshot_object(
optimizer, filename='best_loss_optimizer.npz'),
trigger=best_loss_model_trigger)
if out_dir.exists():
shutil.rmtree(out_dir)
out_dir.mkdir()
# Write parameters text
with open(out_dir / 'train_params.txt', 'w') as f:
f.write('model: {}\n'.format(model.predictor.__class__.__name__))
f.write('n_epoch: {}\n'.format(args.epoch))
f.write('batch_size: {}\n'.format(args.batchsize))
f.write('n_data_train: {}\n'.format(len(train_data)))
f.write('n_data_val: {}\n'.format(len(valid_data)))
f.write('seed: {}\n'.format(args.seed))
f.write('n_fold: {}\n'.format(args.n_fold))
f.write('fold: {}\n'.format(args.fold))
f.write('augmentation: \n')
for process, param in augmentation:
f.write(' {}: {}\n'.format(process, param))
trainer.run()
def main():
args = parse_arguments()
# Set up some useful variables that will be used later on.
dataset_name = args.dataset
method = args.method
num_data = args.num_data
if args.label:
labels = args.label
cache_dir = os.path.join(
'input', '{}_{}_{}'.format(dataset_name, method, labels))
else:
labels = None
cache_dir = os.path.join('input',
'{}_{}_all'.format(dataset_name, method))
# Load the cached dataset.
filename = dataset_part_filename('test', num_data)
path = os.path.join(cache_dir, filename)
if os.path.exists(path):
print('Loading cached dataset from {}.'.format(path))
test = NumpyTupleDataset.load(path)
else:
_, _, test = download_entire_dataset(dataset_name, num_data, labels,
method, cache_dir)
# # Load the standard scaler parameters, if necessary.
# if args.scale == 'standardize':
# scaler_path = os.path.join(args.in_dir, 'scaler.pkl')
# print('Loading scaler parameters from {}.'.format(scaler_path))
# with open(scaler_path, mode='rb') as f:
# scaler = pickle.load(f)
# else:
# print('No standard scaling was selected.')
# scaler = None
# Model-related data is stored this directory.
model_dir = os.path.join(args.in_dir, os.path.basename(cache_dir))
model_filename = {
'classification': 'classifier.pkl',
'regression': 'regressor.pkl'
}
task_type = molnet_default_config[dataset_name]['task_type']
model_path = os.path.join(model_dir, model_filename[task_type])
print("model_path=" + model_path)
print('Loading model weights from {}...'.format(model_path))
if task_type == 'classification':
model = Classifier.load_pickle(model_path, device=args.gpu)
elif task_type == 'regression':
model = Regressor.load_pickle(model_path, device=args.gpu)
else:
raise ValueError('Invalid task type ({}) encountered when processing '
'dataset ({}).'.format(task_type, dataset_name))
# Proposed by Ishiguro
# ToDo: consider go/no-go with following modification
# Re-load the best-validation score snapshot
serializers.load_npz(
os.path.join(model_dir, "best_val_" + model_filename[task_type]),
model)
# # Replace the default predictor with one that scales the output labels.
# scaled_predictor = ScaledGraphConvPredictor(model.predictor)
# scaled_predictor.scaler = scaler
# model.predictor = scaled_predictor
# Run an evaluator on the test dataset.
print('Evaluating...')
test_iterator = SerialIterator(test, 16, repeat=False, shuffle=False)
eval_result = Evaluator(test_iterator,
model,
converter=concat_mols,
device=args.gpu)()
print('Evaluation result: ', eval_result)
# Proposed by Ishiguro: add more stats
# ToDo: considre go/no-go with the following modification
if task_type == 'regression':
#loss = cuda.to_cpu(numpy.array(eval_result['main/loss']))
#eval_result['main/loss'] = loss
# convert to native values..
for k, v in eval_result.items():
eval_result[k] = float(v)
with open(os.path.join(args.in_dir, 'eval_result.json'), 'w') as f:
json.dump(eval_result, f)
# end-with
elif task_type == "classification":
# For Classifier, we do not equip the model with ROC-AUC evalation function
# use a seperate ROC-AUC Evaluator here
rocauc_result = ROCAUCEvaluator(test_iterator,
model,
converter=concat_mols,
device=args.gpu,
eval_func=model.predictor,
name='test',
ignore_labels=-1)()
print('ROCAUC Evaluation result: ', rocauc_result)
with open(os.path.join(args.in_dir, 'eval_result.json'), 'w') as f:
json.dump(rocauc_result, f)
else:
pass
# Save the evaluation results.
with open(os.path.join(model_dir, 'eval_result.json'), 'w') as f:
json.dump(eval_result, f)
def load(self, input_file):
load_npz(input_file, self._model)
# Copy parameter from model to target
self._target.copyparams(self._model)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model', '-m', type=str, required=True,
help='model data, saved by train.py')
parser.add_argument('--file', '-f', type=str, required=True,
help='input text file, used for reaction analysis')
parser.add_argument('--label', type=str, default=None,
help='label file for calculating accuracy')
parser.add_argument('--input_vocab', '-i', type=str, default='data/input_vocab.bin',
help='input text vocaburaly dictionary')
parser.add_argument('--label_vocab', '-l', type=str, default='data/label_vocab.bin',
help='input label vocaburaly dictionary')
parser.add_argument('--seqlen', type=int, required=True,
help='sequence length')
parser.add_argument('-n', type=int, default=3,
help='number of candidates')
parser.add_argument('--fraction', type=float, default=0.0,
help='split ratio of dataset (0 means all data goes to test)')
parser.add_argument('--unit', '-u', type=int, default=650,
help='number of units')
parser.add_argument('--gpu', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
xp = cuda.cupy if args.gpu >= 0 else np
# load dataset and vocabulary
seq_len = args.seqlen
# For testing with labels
# ds = dataset.Dataset(args.file, label=args.label, input_vocab=args.input_vocab, label_vocab=args.label_vocab, seq_len=seq_len)
ds = dataset.Dataset(args.file, label=args.label, input_vocab=args.input_vocab, label_vocab=args.label_vocab, seq_len=seq_len, fraction=args.fraction)
_, test = ds.get_inputs_and_labels()
input_vocab, label_vocab = ds.get_vocab()
input_ivocab = {i: c for c, i in input_vocab.items()}
label_ivocab = {i: c for c, i in label_vocab.items()}
# should be same as n_units, described in train.py
n_units = args.unit
lm = net.RNNLM(len(input_vocab), len(label_vocab), n_units, train=False)
model = L.Classifier(lm)
serializers.load_npz(args.model, model)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
model.to_gpu()
n_top = args.n
n_match = 0
n_total = 0
has_label = (len(test[0]) == len(test[1]))
sys.stdout.write('\n')
for i, data in enumerate(test[0]):
print('[input {0}/{1}]'.format(i + 1, len(test[0])), ' '.join(iconv(data, input_ivocab)))
model.predictor.reset_state()
for j in six.moves.range(seq_len):
word = chainer.Variable(xp.array([data[j]]), volatile='on')
pred = F.softmax(model.predictor(word))
if j == seq_len - 1:
if args.gpu >= 0:
pred_data = cuda.to_cpu(pred.data)
else:
pred_data = pred.data
indice = pred_data[0].argsort()[-n_top:][::-1]
probs = pred_data[0][indice]
result = [(label_ivocab[idx], prob) for (idx, prob) in zip(indice, probs)]
if has_label:
y = test[1][i]
print('[suggested reactions] %s' % result)
n_total += 1
if indice[0] == y:
print(label_ivocab[indice[0]], '(prediction)', '==', label_ivocab[y], '(actual)', '? => MATCH')
n_match += 1
else:
print(label_ivocab[indice[0]], '(prediction)', '==', label_ivocab[y], '(actual)', '? => NOT MATCH')
else:
print('[suggested reactions] %s' % result)
if has_label:
print('cumulative accuracy=%f' % (n_match / n_total))
sys.stdout.write('\n')
self.l1 = L.Linear(None, n_mid_units)
self.l2 = L.Linear(n_mid_units, n_mid_units)
self.l3 = L.Linear(n_mid_units, n_out)
def __call__(self, x):
# データを受け取った際のforward計算を書く
h1 = F.relu(self.l1(x))
h2 = F.relu(self.l2(h1))
return self.l3(h2)
from chainer.cuda import to_cpu
from chainer import serializers
infer_net = MLP()
serializers.load_npz('data/mnist.model', infer_net)
gpu_id = -1
if gpu_id >= 0: # CPUで計算したい場合は-1
infer_net.to_gpu(gpu_id)
def infer(x):
"""
入力xに対する推論結果を返す
:param numpy.ndarray x: 入力
:rtype: (int, [float])
:return: (予測ラベル, [各ラベルに対する出力値])
"""
x = x[None, ...] # ミニバッチの形にする
