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として、そこからランダムにとってきて1にする
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, ...] # ミニバッチの形にする