def __init__(self): super(self.__class__, self).__init__() # set target_names self.target_names = ['background'] + \ [datum['name'] for datum in jsk_apc2016_common.get_object_data()] n_class = len(self.target_names) assert n_class == 40 # load model self.gpu = rospy.get_param('~gpu', 0) chainermodel = rospy.get_param('~chainermodel') self.model = FCN32s(n_class=n_class) S.load_hdf5(chainermodel, self.model) if self.gpu != -1: self.model.to_gpu(self.gpu) jsk_logwarn('>> Model is loaded <<') while True: self.tote_contents = rospy.get_param('~tote_contents', None) if self.tote_contents is not None: break logwarn_throttle(10, 'param ~tote_contents is not set. Waiting..') rospy.sleep(0.1) self.label_names = rospy.get_param('~label_names') jsk_logwarn('>> Param is set <<') self.pub = self.advertise('~output', Image, queue_size=1) self.pub_debug = self.advertise('~debug', Image, queue_size=1)
def test(args): trace('loading model ...') src_vocab = Vocabulary.load(args.model + '.srcvocab') trg_vocab = Vocabulary.load(args.model + '.trgvocab') attmt = AttentionMT.load_spec(args.model + '.spec') if args.use_gpu: attmt.to_gpu() serializers.load_hdf5(args.model + '.weights', attmt) trace('generating translation ...') generated = 0 with open(args.target, 'w') as fp: for src_batch in gens.batch(gens.word_list(args.source), args.minibatch): src_batch = fill_batch(src_batch) K = len(src_batch) trace('sample %8d - %8d ...' % (generated + 1, generated + K)) hyp_batch = forward(src_batch, None, src_vocab, trg_vocab, attmt, False, args.generation_limit) for hyp in hyp_batch: hyp.append('</s>') hyp = hyp[:hyp.index('</s>')] print(' '.join(hyp), file=fp) generated += K trace('finished.')
def __init__(self, gpu, chainermodel=None): self.gpu = gpu self.target_names = fcn.pascal.SegmentationClassDataset.target_names self.n_class = len(self.target_names) if chainermodel is None: chainermodel = osp.join(fcn.data_dir, 'fcn8s_from_caffe.chainermodel') self.model_name = 'fcn8s' self.model = FCN8s(n_class=self.n_class) elif osp.basename(chainermodel).startswith('fcn8s'): self.model_name = 'fcn8s' self.model = FCN8s(n_class=self.n_class) elif osp.basename(chainermodel).startswith('fcn16s'): self.model_name = 'fcn16s' self.model = FCN16s(n_class=self.n_class) elif osp.basename(chainermodel).startswith('fcn32s'): self.model_name = 'fcn32s' self.model = FCN32s(n_class=self.n_class) else: raise ValueError( 'Chainer model filename must start with fcn8s, ' 'fcn16s or fcn32s: {0}'.format(osp.basename(chainermodel))) S.load_hdf5(chainermodel, self.model) if self.gpu != -1: self.model.to_gpu(self.gpu)
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 test(args): trace('loading model ...') word_vocab = Vocabulary.load(args.model + '.words') phrase_vocab = Vocabulary.load(args.model + '.phrases') semiterminal_vocab = Vocabulary.load(args.model + '.semiterminals') parser = Parser.load_spec(args.model + '.spec') if args.use_gpu: parser.to_gpu() serializers.load_hdf5(args.model + '.weights', parser) embed_cache = {} parser.reset() trace('generating parse trees ...') with open(args.source) as fp: for l in fp: word_list = to_vram_words(convert_word_list(l.split(), word_vocab)) tree = combine_xbar( restore_labels( parser.forward(word_list, None, args.unary_limit, embed_cache), phrase_vocab, semiterminal_vocab)) print('( ' + tree_to_string(tree) + ' )') trace('finished.')
def __init__(self, gpu, target_names, chainermodel=None): self.gpu = gpu self.target_names = target_names self.n_class = len(self.target_names) if chainermodel is None: print('Please specify chainermodel.', file=sys.stderr) sys.exit(1) elif osp.basename(chainermodel).startswith('fcn8s'): self.model_name = 'fcn8s' self.model = FCN8s(n_class=self.n_class) elif osp.basename(chainermodel).startswith('fcn16s'): self.model_name = 'fcn16s' self.model = FCN16s(n_class=self.n_class) elif osp.basename(chainermodel).startswith('fcn32s'): self.model_name = 'fcn32s' self.model = FCN32s(n_class=self.n_class) else: raise ValueError( 'Chainer model filename must start with fcn8s, ' 'fcn16s or fcn32s: {0}'.format(osp.basename(chainermodel))) S.load_hdf5(chainermodel, self.model) if self.gpu != -1: self.model.to_gpu(self.gpu)
def test(self): trace('loading model ...') src_vocab = Vocabulary.load(self.model + '.srcvocab') trg_vocab = Vocabulary.load(self.model + '.trgvocab') encdec = EncoderDecoder.load_spec(self.model + '.spec') serializers.load_hdf5(self.model + '.weights', encdec) trace('generating translation ...') generated = 0 with open(self.target, 'w') as fp: for src_batch in gens.batch(gens.word_list(self.source), self.minibatch): src_batch = fill_batch(src_batch) K = len(src_batch) trace('sample %8d - %8d ...' % (generated + 1, generated + K)) hyp_batch = self.forward(src_batch, None, src_vocab, trg_vocab, encdec, False, self.generation_limit) source_cuont = 0 for hyp in hyp_batch: hyp.append('</s>') hyp = hyp[:hyp.index('</s>')] print("src : " + "".join(src_batch[source_cuont]).replace("</s>", "")) print('hyp : ' +''.join(hyp)) print(' '.join(hyp), file=fp) source_cuont = source_cuont + 1 generated += K trace('finished.')
def load_model(path): model_base_path = os.path.dirname(path) model_def_path = os.path.join(model_base_path, MODEL_DEF_NAME) with open(model_def_path, 'rb') as f: model = pickle.load(f) # load model definition load_hdf5(path, model) # load parameters return model
def test(args): source_vocab = Vocab.load(args.model_path+SRC_VOCAB_NAME) target_vocab= Vocab.load(args.model_path+TAR_VOCAB_NAME) vocab_size, hidden_size, maxout_hidden_size, embed_size = Backup.load(args.model_path+HPARAM_NAME) att_encdec = ABED(vocab_size, hidden_size, maxout_hidden_size, embed_size) if args.use_gpu: att_encdec.to_gpu() serializers.load_hdf5(args.model_path+str(args.epochs)+'.attencdec', att_encdec) with open(args.output+str(args.epochs), 'w') as fp: source_gen = word_list(args.source) target_gen = word_list(args.target) batch_gen = batch(sort(source_gen, target_gen, 100*args.minibatch), args.minibatch) for source_batch, target_batch in batch_gen: source_batch = fill_batch_end(source_batch) target_batch = fill_batch_end(target_batch) if args.beam_search: hyp_batch = forward_beam(source_batch, None, source_vocab, target_vocab, att_encdec, False, args.limit, args.beam_size) else: hyp_batch = forward(source_batch, None, source_vocab, target_vocab, att_encdec, False, args.limit) for i, hyp in enumerate(hyp_batch): hyp.append(END) hyp = hyp[:hyp.index(END)] show(source_batch[i], target_batch[i], hyp, "TEST") fwrite(source_batch[i], target_batch[i], hyp, fp)
def main(): parser = argparse.ArgumentParser() parser.add_argument('raw_path') parser.add_argument('model_path') args = parser.parse_args() raw_path = args.raw_path model_path = args.model_path mask_path = raw_to_mask_path(raw_path) raw = imread(raw_path) mask = imread(mask_path) y_min, x_min, y_max, x_max = mask_to_roi(mask) im = raw[y_min:y_max, x_min:x_max] model = VGG_mini_ABN() serializers.load_hdf5(model_path, model) im = resize(im, (128, 128), preserve_range=True) x_data = np.array([im_to_blob(im)], dtype=np.float32) x = Variable(x_data, volatile=True) model.train = False y = model(x) y_data = y.data print(OBJECT_CLASSES[np.argmax(y_data[0])])
def main(): parser = argparse.ArgumentParser() parser.add_argument('chainermodel') parser.add_argument('--gpu', type=int, default=0) args = parser.parse_args() chainermodel = args.chainermodel gpu = args.gpu save_dir = 'test_result' if not osp.exists(save_dir): os.makedirs(save_dir) dataset = apc2016.APC2016Dataset() n_class = len(dataset.target_names) model = VGG16(n_class=n_class) S.load_hdf5(chainermodel, model) if gpu != -1: model.to_gpu(gpu) batch_size = 25 index = 0 sum_accuracy = 0 label_true_all = [] label_pred_all = [] for index_start in xrange(0, len(dataset.test), batch_size): indices = range(index_start, min(len(dataset.test), index_start + batch_size)) x, t = dataset.next_batch(batch_size, type='test', type_indices=indices) if gpu != -1: x = cuda.to_gpu(x, gpu) t = cuda.to_gpu(t, gpu) x = Variable(x, volatile=True) t = Variable(t, volatile=True) model(x, t) x_data = cuda.to_cpu(x.data) accuracy = float(cuda.to_cpu(model.acc.data)) sum_accuracy += accuracy * len(x_data) label_true = cuda.to_cpu(t.data) label_pred = cuda.to_cpu(model.pred.data).argmax(axis=1) label_true_all.extend(label_true.tolist()) label_pred_all.extend(label_pred.tolist()) fname = '{0}_{1}-{2}_{3:.2}.png'.format( osp.basename(chainermodel), indices[0], indices[-1], accuracy) fname = osp.join(save_dir, fname) draw_test_result(dataset, fname, x_data, label_true, label_pred, n_class) print('Saved {0}.'.format(fname)) mean_accuracy = sum_accuracy / len(dataset.test) print('Accuracy: {0}'.format(mean_accuracy)) print(classification_report( y_true=label_true_all, y_pred=label_pred_all, labels=np.arange(len(dataset.target_names)), target_names=dataset.target_names, ))
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_hdf5(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(): # Settings act = F.relu # Model ae = AutoEncoder(act) # Load fpath = "/home/kzk/tmp/cnn/ae_00010.h5py" serializers.load_hdf5(fpath, ae) # Data home = os.environ.get("HOME") train_path = os.path.join(home, "datasets/mnist/train.npz") data = np.load(train_path) # Generate random vector(s) idx = 150 x = data["x"][idx, :].reshape(1, 1, 28, 28).astype(np.float32) x = (x - 127.5) / 127.5 y = ae.encoder(x) #y = F.softmax(y) # Generate sample(s) x = ae.decoder(y, test=True) x = x.data * 127.5 + 127.5 cv2.imwrite("./dec_mnist_{:05d}.png".format(0), x.reshape(28, 28))
def __judge_print(self): """ judge slack call for chainer Example: chainer:{your sentence} chainer return the sentence chainer_train:{your sentence} start train """ if len(self.data) >= 1 and "text" in self.data[0]: print(self.data[0]["text"]) if "chainer:" in self.data[0]["text"]: # input sentence src_batch = self.__input_sentence() # predict hyp_batch = self.__predict_sentence(src_batch) # show predict word word = ''.join(hyp_batch[0]).replace("</s>", "") print(self.slack_channel.api_call("chat.postMessage", user=self.usr, channel=self.chan, text=word)) if "chainer_train" in self.data[0]["text"]: self.__setting_parameter() model = AttentionDialogue.load_spec(self.model_name + '.spec', self.XP) dialogue = EncoderDecoderModelAttention(self.parameter) serializers.load_hdf5(self.model_name + '.weights', model) dialogue.attention_dialogue = model dialogue.word2vecFlag = False dialogue.train()
def inspect(image_path, mean, model_path, label, network, gpu=-1): network = network.split(os.sep)[-1] model_name = re.sub(r"\.py$", "", network) model_module = load_module(os.path.dirname(model_path), model_name) mean_image = pickle.load(open(mean, 'rb')) model = model_module.Network() serializers.load_hdf5(model_path, model) if gpu >= 0: cuda.check_cuda_available() cuda.get_device(gpu).use() model.to_gpu() cropwidth = 256 - model.insize img = read_image(image_path, model, mean_image, cropwidth) x = np.ndarray((1, 3, model.insize, model.insize), dtype=np.float32) x[0] = img if gpu >= 0: x = cuda.to_gpu(x) score = model.predict(x) score = cuda.to_cpu(score.data) categories = np.loadtxt(label, str, delimiter="\t") top_k = 20 prediction = zip(score[0].tolist(), categories) prediction.sort(cmp=lambda x, y:cmp(x[0], y[0]), reverse=True) ret = [] for rank, (score, name) in enumerate(prediction[:top_k], start=1): ret.append({"rank": rank, "name": name, "score": "{0:4.1f}%".format(score*100)}) return ret
def init_model(): global model, optimizer model = PBLLogi() optimizer = optimizers.Adam() optimizer.setup(model) serializers.load_hdf5('pbllogi.model', model) serializers.load_hdf5('pbllogi.state', optimizer)
def __predict_sentence(self, src_batch): dialogue = EncoderDecoderModelForwardSlack(self.parameter) src_vocab = Vocabulary.load(self.model_name + '.srcvocab') trg_vocab = Vocabulary.load(self.model_name + '.trgvocab') model = EncoderDecoder.load_spec(self.model_name + '.spec') serializers.load_hdf5(dialogue.model + '.weights', model) hyp_batch = dialogue.forward(src_batch, None, src_vocab, trg_vocab, model, False, self.generation_limit) return hyp_batch
def load_model(self): model_fn = os.path.basename(self.args.model) self.model = imp.load_source( model_fn.split('.')[0], self.args.model).model self.model.train = False serializers.load_hdf5(self.args.param, self.model) if self.args.gpu >= 0: self.model.to_gpu()
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 serializers.load_hdf5(args.param, model) model.train = False return model
def load_model(filename, model): print('Loading pretrained model...') try: serializers.load_hdf5(filename, model) print('Loaded pretrained model') except OSError as err: print('OS error: {}'.format(err)) print('Could not find a pretrained model. Proceeding with a randomly initialized model.')
def load(self): filename = "fc.model" if os.path.isfile(filename): serializers.load_hdf5(filename, self.fc) print "model loaded successfully." filename = "fc.optimizer" if os.path.isfile(filename): serializers.load_hdf5(filename, self.optimizer_fc) print "optimizer loaded successfully."
def load(self): filename = "conv.model" if os.path.isfile(filename): serializers.load_hdf5(filename, self.conv) print "convolutional network loaded." if self.fcl_eliminated is False: filename = "fc.model" if os.path.isfile(filename): serializers.load_hdf5(filename, self.fc) print "fully-connected network loaded."
def load_model(filename, model): """Load the model with the file data.""" print('Loading pretrained model...') try: serializers.load_hdf5(filename, model) print('Successfully loaded pretrained model') except OSError as err: print('OS error: {}'.format(err)) print('Could not find a pretrained model. \ Proceeding with a randomly initialized model.')
def main(): rospy.init_node('cae_param_node') model = CAEOnes(n_param=1) S.load_hdf5('cae_ones_model_inbin_trained.h5', model) model.train = False CAENode(model) rospy.spin()
def __init__(self, net_size, model_filename, optimizer_filename): """ Create the underlying neural network model """ self.model = L.Classifier(BaseNetwork(net_size)) if (model_filename != ""): serializers.load_hdf5(model_filename, self.model) """ Create the underlying optimizer """ self.optimizer = optimizers.Adam() self.optimizer.setup(self.model) if (optimizer_filename != ""): serializers.load_hdf5(optimizer_filename, self.optimizer)
def __init__(self, args): trace('loading model ...') self.args = args self.src_vocab = Vocabulary.load(args.model + '.srcvocab') self.trg_vocab = Vocabulary.load(args.model + '.trgvocab') self.encdec = EncoderDecoder.load_spec(args.model + '.spec') if args.use_gpu: self.encdec.to_gpu() serializers.load_hdf5(args.model + '.weights', self.encdec) trace('generating translation ...')
def load_model(self, model_filename): """Load a network model form a file """ serializers.load_hdf5(model_filename, self.model) copy_param.copy_param(target_link=self.model, source_link=self.shared_model) opt_filename = model_filename + '.opt' if os.path.exists(opt_filename): print('WARNING: {0} was not found, so loaded only a model'.format( opt_filename)) serializers.load_hdf5(model_filename + '.opt', self.optimizer)
def load_latest(train=True): model = load_new(train) params = os.listdir('speaker-model') params.sort() if len(params) > 0: serializers.load_hdf5(os.path.join('speaker-model', params[-1]), model) return model, params[-1] else: return model, None
def get_model(name): if name == 'vgg16': model = VGG16() elif name == 'caffenet': model = CaffeNet() elif name == 'vgg_cnn_m_1024': model = VGG_CNN_M_1024() else: raise ValueError('Unsupported model name: %s' % name) S.load_hdf5('models/%s.chainermodel' % name, model) model.to_gpu() return model
def test(args): """ 予測を行うメソッド """ batchsize = args.batchsize # バッチサイズ # 語彙辞書の読込 src_vocab2id, src_id2vocab, vocab_size = util.load_vocab(args.model + ".srcvocab") # モデルの読込 model = NLM.load_spec(args.model + ".spec") # GPUを使うかどうか if args.use_gpu: cuda.check_cuda_available() cuda.get_device(1).use() model.to_gpu() xp = cuda.cupy if args.use_gpu else np # args.gpu <= 0: use cpu, otherwise: use gpu serializers.load_hdf5(args.model + ".weights", model) # Source sequence for test print 'loading source data for test...' # データセット読み込み test_src_dataset = util.load_test_src_data(args.src, src_vocab2id) generated = 0 N = len(test_src_dataset) # テストの事例数 word_list = src_vocab2id.keys() # 単語wordのembeddingを取得 word_id_list = Variable(xp.asarray([src_vocab2id[word] for word in word_list ], dtype=xp.int32)) embedding_list = model.get_embedding(word_id_list) src_embed = embedding_list.data[word_list.index(args.src_word)] #print model.embed.W.data.shape print "src word:", args.src_word print src_embed #src_embed = model.embed.W.data[src_vocab2id[args.src_word]] trg_embed_list = {} for _word, _id in src_vocab2id.items(): trg_embed = embedding_list.data[word_list.index(_word)] #trg_embed = model.embed.W.data[src_vocab2id[_word]] trg_embed_list[_word] = 1 - scipy.spatial.distance.cosine(src_embed, trg_embed) # 上位10件を表示 for i, (word, sim) in enumerate(sorted(trg_embed_list.items(), key=lambda x:x[1], reverse=True)): print word, sim if i == 10: break
def load_model(self, filename): serializers.load_hdf5(filename, self)
if __name__ == '__main__': args = parse() vocab = pickle.load(open(args.vocab, 'rb')) print("Loading Model...") if args.mode == 'naive': from Recursive_model import RecursiveNet model = RecursiveNet(len(vocab), args.embed_size, args.unit, args.label) if args.gpu >= 0: cuda.get_device(args.gpus).use() model.to_gpu(args.gpu) xp = cuda.cupy serializers.load_hdf5(args.model, model) print("Begin reordering...") for i, fp in enumerate(args.reorderfile): with codecs.open(fp.split('/')[-1] + '.re', 'w', 'utf-8') as fre: for tree in read_reorder(fp, vocab, args.tree_type): _, pred, order = traverse(model, tree, 0, train=False, pred=True) if args.output_format == 'text': print(' '.join(pred), file=fre) elif args.output_format == 'order': hd = {} for oi, o in enumerate(order): hd[o] = oi
def load(self, filename): if os.path.isfile(filename): print("loading {} ...".format(filename)) serializers.load_hdf5(filename, self) else: print(filename, "not found.")
def main(params): target_save_dir = osp.join(params['save_dir'], 'prepro', params['dataset'] + '_' + params['splitBy']) model_dir = osp.join(params['save_dir'], 'model', params['dataset'] + '_' + params['splitBy']) if params['old']: params['data_json'] = 'old' + params['data_json'] params['data_h5'] = 'old' + params['data_h5'] params['image_feats'] = 'old' + params['image_feats'] params['ann_feats'] = 'old' + params['ann_feats'] params['id'] = 'old' + params['id'] if params['dataset'] in ['refcoco', 'refcoco+', 'refcocog']: global_shapes = (224, 224) image_root = params['coco_image_root'] elif params['dataset'] == 'refgta': global_shapes = (480, 288) image_root = params['gta_image_root'] with open(target_save_dir + params["split"] + '_' + params['id'] + params['id2'] + str(params['beam_width']) + '.json') as f: data = json.load(f) ref_to_beams = {item['ref_id']: item['beam'] for item in data} # add ref_id to each beam for ref_id, beams in ref_to_beams.items(): for beam in beams: beam['ref_id'] = ref_id # make up ref_id in beam loader = DataLoader(params) featsOpt = { 'sp_ann': osp.join(target_save_dir, params['sp_ann_feats']), 'ann_input': osp.join(target_save_dir, params['ann_feats']), 'img': osp.join(target_save_dir, params['image_feats']), 'shapes': osp.join(target_save_dir, params['ann_shapes']) } loader.loadFeats(featsOpt) loader.shuffle('train') loader.loadFeats(featsOpt) chainer.config.train = False chainer.config.enable_backprop = False gpu_id = params['gpu_id'] cuda.get_device(gpu_id).use() xp = cuda.cupy rl_crit = ListenerReward(len(loader.ix_to_word), global_shapes=global_shapes).to_gpu(gpu_id) serializers.load_hdf5(osp.join(model_dir, params['id'] + ".h5"), rl_crit) #serializers.load_hdf5(osp.join(model_dir, "attn_rank.h5"), rl_crit) img_to_ref_ids, img_to_ref_confusion = calc_confusion( loader, data, ref_to_beams, rl_crit, params, xp) sys.path.insert(0, osp.join('pyutils', 'refer2')) sys.path.insert(0, osp.join('pyutils', 'refer2', 'evaluation')) from refer import REFER from refEvaluation import RefEvaluation from crossEvaluation import CrossEvaluation refer = REFER(params['data_root'], image_root, params['dataset'], params['splitBy'], old_version=params['old']) if params['dataset'] == 'refcoco': lambda1 = 5 lambda2 = 5 elif params['dataset'] == 'refcoco+': lambda1 = 5 lambda2 = 5 elif params['dataset'] == 'refcocog': lambda1 = 5 lambda2 = 5 elif params['dataset'] == 'refgta': lambda1 = 5 lambda2 = 5 else: error('No such dataset option for ', params['dataset']) # compute unary potential, img_to_ref_unary # let's firstly try one image Res = [] for image_id in img_to_ref_confusion: # ref_ids and confusion matrices for this image img_ref_ids = img_to_ref_ids[image_id] ref_to_confusion = img_to_ref_confusion[image_id] # compute unary potential for each ref_id for ref_id in img_ref_ids: confusion = ref_to_confusion[ref_id] # (beam_size, #img_ref_ids) beams = ref_to_beams[ref_id] # [{ppl, sent, logp}] of beam_size compute_unary(ref_id, beams, confusion, img_ref_ids, lambda1, lambda2) # here's more preparation ref_beam_to_ix, ix_to_ref_beam, all_beams = make_index( img_ref_ids, ref_to_beams) # compute pairwise potentials pairwise_ref_beam_ids = compute_pairwise(img_ref_ids, ref_to_beams) # call cplex res = bilp(img_ref_ids, ref_to_beams, all_beams, pairwise_ref_beam_ids, ref_beam_to_ix, loader) Res += res # evaluate eval_cider_r = params['dataset'] == 'refgta' refEval = RefEvaluation(refer, Res, eval_cider_r=eval_cider_r) refEval.evaluate() overall = {} for metric, score in refEval.eval.items(): overall[metric] = score print(overall) if params['write_result'] > 0: refToEval = refEval.refToEval for res in Res: ref_id, sent = res['ref_id'], res['sent'] refToEval[ref_id]['sent'] = sent with open('' + params['id'] + params['id2'] + '_out.json', 'w') as outfile: json.dump({'overall': overall, 'refToEval': refToEval}, outfile) # CrossEvaluation takes as input [{ref_id, sent}] ceval = CrossEvaluation(refer, Res) ceval.cross_evaluate() ceval.make_ref_to_evals() ref_to_evals = ceval.ref_to_evals # ref_to_evals = {ref_id: {ref_id: {method: score}}} # compute cross score xcider = ceval.Xscore('CIDEr')
def output_file(data_path, model_path): """ :param data_path: the path of corpus you made model learn :param model_path: the path of model you made learn :return: """ # call dictionary class corpus = JaConvCorpus(create_flg=False) corpus.load(load_dir=data_path) print('Vocabulary Size (number of words) :', len(corpus.dic.token2id)) print('') # rebuild seq2seq model model = FineTuneSeq2Seq(all_vocab_size=len(corpus.dic.token2id), emotion_vocab_size=len(corpus.emotion_set), feature_num=args.feature_num, hidden_num=args.hidden_num, label_num=args.label_num, label_embed_num=args.label_embed, batch_size=1, gpu_flg=args.gpu) serializers.load_hdf5(model_path, model) emo_label_index = [index for index in range(args.label_num)] topic_label_index = [index for index in range(args.topic_num)] # run conversation system r_label = re.compile("(__label__)([0-9]+)") pattern = "(.+?)(\t)(.+?)(\n|\r\n)" r = re.compile(pattern) for line in open(T2V_OUTPUT, 'r', encoding='utf-8'): m = r.search(line) if m is not None: topic_label = m.group(1) sentence = m.group(3) # check a topic tag label_info = r_label.search(topic_label) if int(label_info.group(2)) < len(topic_label_index): topic_label_id = int(label_info.group(2)) else: print('domain label がドメイン数の上限を超えています.') raise ValueError # parse text by mecab input_vocab = [unicodedata.normalize('NFKC', word.lower()) for word in parse_ja_text(sentence)] input_vocab_rev = input_vocab[::-1] # convert word into ID input_sentence = [corpus.dic.token2id[word] for word in input_vocab if not corpus.dic.token2id.get(word) is None] input_sentence_rev = [corpus.dic.token2id[word] for word in input_vocab_rev if not corpus.dic.token2id.get(word) is None] print("input -> ", sentence, "domain:", topic_label_id) model.initialize(batch_size=1) for emo_label in range(LABEL_NUM): sentence = model.generate(input_sentence, input_sentence_rev, sentence_limit=len(input_sentence) + 20, emo_label_id=emo_label, topic_label_id=topic_label_id, word2id=corpus.dic.token2id, id2word=corpus.dic) if emo_label == 0: print("neg -> ", sentence) elif emo_label == 1: print("neu -> ", sentence) elif emo_label == 2: print("pos -> ", sentence) else: raise ValueError print('')
def interpreter(data_path, model_path): """ Run this function, if you want to talk to seq2seq model. if you type "exit", finish to talk. :param data_path: the path of corpus you made model learn :param model_path: the path of model you made learn :return: """ # call dictionary class corpus = JaConvCorpus(create_flg=False) corpus.load(load_dir=data_path) print('Vocabulary Size (number of words) :', len(corpus.dic.token2id)) print('') # rebuild seq2seq model model = FineTuneSeq2Seq(all_vocab_size=len(corpus.dic.token2id), emotion_vocab_size=len(corpus.emotion_set), feature_num=args.feature_num, hidden_num=args.hidden_num, label_num=args.label_num, label_embed_num=args.label_embed, batch_size=1, gpu_flg=args.gpu) serializers.load_hdf5(model_path, model) emo_label_index = [index for index in range(args.label_num)] topic_label_index = [index for index in range(args.topic_num)] # run conversation system print('The system is ready to run, please talk to me!') print('( If you want to end a talk, please type "exit". )') print('') while True: print('>> ', end='') sentence = input() if sentence == 'exit': print('See you again!') break # check a sentiment tag input_vocab = sentence.split(' ') emo_label_id = input_vocab.pop(-1) topic_label_id = input_vocab.pop(-1) label_false_flg = 1 for index in emo_label_index: if emo_label_id == str(index): emo_label_id = index # TODO: ラベルのインデックスに注意.今は3値分類 (0, 1, 2) label_false_flg = 0 break if label_false_flg: print('caution: you donot set any enable tags! (emotion label)') emo_label_id = -1 # check a topic tag # TODO: 本当はユーザ側の指定ではなく,tweet2vecの判定から決定する label_false_flg = 1 for index in topic_label_index: if topic_label_id == str(index): topic_label_id = index # TODO: ラベルのインデックスに注意.今は3値分類 (0, 1, 2) label_false_flg = 0 break if label_false_flg: print('caution: you donot set any enable tags! (topic label)') topic_label_id = -1 input_vocab = [unicodedata.normalize('NFKC', word.lower()) for word in parse_ja_text(sentence)] input_vocab_rev = input_vocab[::-1] # convert word into ID input_sentence = [corpus.dic.token2id[word] for word in input_vocab if not corpus.dic.token2id.get(word) is None] input_sentence_rev = [corpus.dic.token2id[word] for word in input_vocab_rev if not corpus.dic.token2id.get(word) is None] model.initialize(batch_size=1) if args.beam_search: hypotheses = model.beam_search(model.initial_state_function, model.generate_function, input_sentence, input_sentence_rev, start_id=corpus.dic.token2id['<start>'], end_id=corpus.dic.token2id['<eos>'], emo_label_id=emo_label_id, topic_label_id=topic_label_id) for hypothesis in hypotheses: generated_indices = hypothesis.to_sequence_of_values() generated_tokens = [corpus.dic[i] for i in generated_indices] print("--> ", " ".join(generated_tokens)) else: sentence = model.generate(input_sentence, input_sentence_rev, sentence_limit=len(input_sentence) + 20, emo_label_id=emo_label_id, topic_label_id=topic_label_id, word2id=corpus.dic.token2id, id2word=corpus.dic) print("-> ", sentence) print('')
#try to load from here item_path = "./items" item_files = glob.glob(item_path + "/*") image_file = args.path labels = [] input_height, input_width = (224, 224) for i, item in enumerate(item_files): labels.append(item.split("/")[-1].split(".")[0]) print(item.split("/")[-1].split(".")[0]) weight_file_test = "./backup/1001.model" model_test = Darknet19Predictor(Darknet19()) serializers.load_hdf5(weight_file_test, model_test) # load saved model model_test.predictor.train = False # read image and process on it img1 = cv2.imread(image_file) img2 = cv2.imread("./items/schweps.png") img3 = cv2.imread("./items/coca-zero.png") # forward x = [] img_list = [] img_list.append(img1) img_list.append(img2) img_list.append(img3) cv2.imshow('test feed', img1)
n_epoch = 81 # 保存先をチェックする if os.path.exists('models/' + args.dir): print('selected dir exists!') else: print('selected dir does not exits! make dir.') os.mkdir('models/' + args.dir) # 各種必要なパラメータを読み込み # VGGmodelを読み込む if args.usevgg == 1: print('loading VGG model...') vgg = VGGNet() serializers.load_hdf5('/tmp/VGG.model', vgg) print('loaded VGG!') # ############学習の高速化のためにパラメータを事前に整理しておく################### if args.usevgg == 1: print('preprocessing vgg data') vgg_img_param = [] start = time.time() if os.path.isfile('features/vggparam_leather.pickle'): print('vgg checkpoint pickle is exist! loading pickle') with open('features/vggparam_leather.pickle', mode='rb') as f: vgg_img_param = pickle.load(f) else: for filename in filenames:
vocab_size = 3000 seq_length = 30 start_token = 0 if args.ae_pretrain: encoder = SeqEncoder(vocab_size=vocab_size, emb_dim=args.gen_emb_dim, hidden_dim=args.gen_hidden_dim, sequence_length=seq_length) else: encoder = None # generator generator = SeqGAN(vocab_size=vocab_size, emb_dim=args.gen_emb_dim, hidden_dim=args.gen_hidden_dim, sequence_length=seq_length, start_token=start_token, lstm_layer=args.num_lstm_layer, dropout=args.dropout, free_pretrain=args.free_pretrain, encoder=encoder).to_gpu() if args.gen: serializers.load_hdf5(args.gen, generator) # discriminator discriminator = TextCNN(num_classes=2, vocab_size=vocab_size, embedding_size=args.dis_embedding_dim, filter_sizes=[int(n) for n in args.dis_filter_sizes.split(',')], num_filters=[int(n) for n in args.dis_num_filters.split(',')] ).to_gpu() if args.dis: serializers.load_hdf5(args.dis, discriminator) # set optimizer if args.ae_pretrain: enc_optimizer = optimizers.Adam(alpha=args.gen_lr) enc_optimizer.setup(encoder) enc_optimizer.add_hook(chainer.optimizer.GradientClipping(args.gen_grad_clip))
sty_len[sty_idx] = lengths # Count all token frequencies tok_idx, freq = np.unique(flattened, return_counts=True) term_frequency = np.zeros(n_vocab, dtype='int32') term_frequency[tok_idx] = freq model = LDA2Vec(n_stories=n_stories, n_story_topics=n_story_topics, n_units=n_units, n_vocab=n_vocab, counts=term_frequency, n_samples=15) if os.path.exists('lda2vec.hdf5'): print "Reloading from saved" serializers.load_hdf5("lda2vec.hdf5", model) model.to_gpu() optimizer = O.Adam() optimizer.setup(model) clip = chainer.optimizer.GradientClipping(5.0) optimizer.add_hook(clip) author_id = story_id j = 0 epoch = 0 fraction = batchsize * 1.0 / flattened.shape[0] for epoch in range(5000): ts = prepare_topics( cuda.to_cpu(model.mixture_sty.weights.W.data).copy(), cuda.to_cpu(model.mixture_sty.factors.W.data).copy(), cuda.to_cpu(model.sampler.W.data).copy(), words)
momentum = 0.9 weight_decay = 0.0005 # load image generator print("loading image generator...") generator = ImageGenerator(item_path, background_path) with open(label_file, "r") as f: labels = f.read().strip().split("\n") # load model print("loading model...") model = Darknet19Predictor(Darknet19()) backup_file = "%s/backup.model" % (backup_path) if os.path.isfile(backup_file): serializers.load_hdf5(initial_weights_file, model) # load saved model model.predictor.train = True model.predictor.finetune = True cuda.get_device(0).use() model.to_gpu() # for gpu optimizer = optimizers.MomentumSGD(lr=learning_rate, momentum=momentum) optimizer.use_cleargrads() optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(weight_decay)) # start to train print("start training") for batch in range(max_batches): # generate sample x, t = generator.generate_samples(n_samples=batch_size,
transport, n_update, k=k, lr=args.lr, optmode=args.optmode) fileobj.write("n_update:{}\n".format(n_update)) fileobj.write("IS:{}pm{}\n".format(inception_mean, inception_std)) fileobj.write("FID:{}\n\n".format(fid)) if __name__ == '__main__': args = parse_args() if not os.path.exists("scores"): os.mkdir("scores") evmodel = Inception() serializers.load_hdf5('metric/inception_score.model', evmodel) G, D, data = load_GD(args.G, args.D) if args.gpu >= 0: cuda.get_device(args.gpu).use() evmodel.to_gpu() G.to_gpu() D.to_gpu() G, D = DOT.thermalize_spectral_norm(G, D) if args.k == None: k = DOT.eff_k(G, D) else: k = args.k * xp.ones([1]) main(args, G, D, data,