def decode_main(use_cuda, is_sparse): if use_cuda and not fluid.core.is_compiled_with_cuda(): return place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() context = encoder(is_sparse) translation_ids, translation_scores = decode(context, is_sparse) exe = Executor(place) exe.run(framework.default_startup_program()) init_ids_data = np.array([1 for _ in range(batch_size)], dtype='int64') init_scores_data = np.array( [1. for _ in range(batch_size)], dtype='float32') init_ids_data = init_ids_data.reshape((batch_size, 1)) init_scores_data = init_scores_data.reshape((batch_size, 1)) init_lod = [1] * batch_size init_lod = [init_lod, init_lod] init_ids = fluid.create_lod_tensor(init_ids_data, init_lod, place) init_scores = fluid.create_lod_tensor(init_scores_data, init_lod, place) train_data = paddle.batch( paddle.reader.shuffle( paddle.dataset.wmt14.train(dict_size), buf_size=1000), batch_size=batch_size) feed_order = ['src_word_id'] feed_list = [ framework.default_main_program().global_block().var(var_name) for var_name in feed_order ] feeder = fluid.DataFeeder(feed_list, place) for data in train_data(): feed_dict = feeder.feed(map(lambda x: [x[0]], data)) feed_dict['init_ids'] = init_ids feed_dict['init_scores'] = init_scores result_ids, result_scores = exe.run( framework.default_main_program(), feed=feed_dict, fetch_list=[translation_ids, translation_scores], return_numpy=False) print result_ids.lod() break
def infer(use_cuda, inference_program, params_dirname): place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() inferencer = fluid.Inferencer( inference_program, param_path=params_dirname, place=place) # Use the first data from paddle.dataset.movielens.test() as input. # Use create_lod_tensor(data, lod, place) API to generate LoD Tensor, # where `data` is a list of sequences of index numbers, `lod` is # the level of detail (lod) info associated with `data`. # For example, data = [[10, 2, 3], [2, 3]] means that it contains # two sequences of indexes, of length 3 and 2, respectively. # Correspondingly, lod = [[3, 2]] contains one level of detail info, # indicating that `data` consists of two sequences of length 3 and 2. user_id = fluid.create_lod_tensor([[1]], [[1]], place) gender_id = fluid.create_lod_tensor([[1]], [[1]], place) age_id = fluid.create_lod_tensor([[0]], [[1]], place) job_id = fluid.create_lod_tensor([[10]], [[1]], place) movie_id = fluid.create_lod_tensor([[783]], [[1]], place) category_id = fluid.create_lod_tensor([[10, 8, 9]], [[3]], place) movie_title = fluid.create_lod_tensor([[1069, 4140, 2923, 710, 988]], [[5]], place) results = inferencer.infer( { 'user_id': user_id, 'gender_id': gender_id, 'age_id': age_id, 'job_id': job_id, 'movie_id': movie_id, 'category_id': category_id, 'movie_title': movie_title }, return_numpy=False) print("infer results: ", np.array(results[0]))
def infer(use_cuda, params_dirname): place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() infer_movie_id = 783 infer_movie_name = paddle.dataset.movielens.movie_info( )[infer_movie_id].title exe = fluid.Executor(place) inference_scope = fluid.core.Scope() ids = [] with fluid.scope_guard(inference_scope): [inferencer, feed_target_names, fetch_targets] = fluid.io.load_inference_model(params_dirname, exe) # Use the first data from paddle.dataset.movielens.test() as input assert feed_target_names[0] == "user_id" user_id = fluid.create_lod_tensor([[np.int64(1)]], [[1]], place) assert feed_target_names[1] == "gender_id" gender_id = fluid.create_lod_tensor([[np.int64(1)]], [[1]], place) assert feed_target_names[2] == "age_id" age_id = fluid.create_lod_tensor([[np.int64(0)]], [[1]], place) assert feed_target_names[3] == "job_id" job_id = fluid.create_lod_tensor([[np.int64(10)]], [[1]], place) assert feed_target_names[4] == "movie_id" movie_id = fluid.create_lod_tensor([[np.int64(783)]], [[1]], place) assert feed_target_names[5] == "category_id" category_id = fluid.create_lod_tensor( [np.array([10, 8, 9], dtype='int64')], [[3]], place) assert feed_target_names[6] == "movie_title" movie_title = fluid.create_lod_tensor( [np.array([1069, 4140, 2923, 710, 988], dtype='int64')], [[5]], place) ids.append(infer_movie_id) results = exe.run(inferencer, feed={ feed_target_names[0]: user_id, feed_target_names[1]: gender_id, feed_target_names[2]: age_id, feed_target_names[3]: job_id, feed_target_names[4]: movie_id, feed_target_names[5]: category_id, feed_target_names[6]: movie_title }, fetch_list=fetch_targets, return_numpy=False) predict_rating = np.array(results[0]) usr_features = np.array(results[1]) mov_features = np.array(results[2]) print("Predict Rating of user id 1 on movie id 783 is " + str(predict_rating[0][0])) print("Actual Rating of user id 1 on movie id 783 is 4.") return usr_features[0], mov_features[0], ids
def test_Variable(): x1 = fluid.create_lod_tensor( np.zeros((4, 784)), [[1, 1, 1, 1]], fluid.CPUPlace()) fluid.layers.uniform_random(x1)
import paddle.fluid as fluid import numpy as np def LodTensor_to_Tensor(lod_tensor): lod = lod_tensor.lod() print("lod :", lod) array = np.array(lod_tensor) print("array :", array) new_array = [] for i in range(len(lod[0]) - 1): new_array.append(array[lod[0][i]:lod[0][i + 1]]) return new_array a = fluid.create_lod_tensor( np.array([[1.1], [2.2], [3.3], [4.4]]).astype('float32'), [[1, 3]], fluid.CPUPlace()) new_array = LodTensor_to_Tensor(a) print(new_array)
def infer(use_cuda, params_dirname=None): place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() exe = fluid.Executor(place) inference_scope = fluid.core.Scope() with fluid.scope_guard(inference_scope): # Use fluid.io.load_inference_model to obtain the inference program desc, # the feed_target_names (the names of variables that will be feeded # data using feed operators), and the fetch_targets (variables that # we want to obtain data from using fetch operators). [inferencer, feed_target_names, fetch_targets] = fluid.io.load_inference_model(params_dirname, exe) # Setup inputs by creating 4 LoDTensors representing 4 words. Here each word # is simply an index to look up for the corresponding word vector and hence # the shape of word (base_shape) should be [1]. The recursive_sequence_lengths, # which is length-based level of detail (lod) of each LoDTensor, should be [[1]] # meaning there is only one level of detail and there is only one sequence of # one word on this level. # Note that recursive_sequence_lengths should be a list of lists. data1 = numpy.asarray([[211]], dtype=numpy.int64) # 'among' data2 = numpy.asarray([[6]], dtype=numpy.int64) # 'a' data3 = numpy.asarray([[96]], dtype=numpy.int64) # 'group' data4 = numpy.asarray([[4]], dtype=numpy.int64) # 'of' lod = numpy.asarray([[1]], dtype=numpy.int64) first_word = fluid.create_lod_tensor(data1, lod, place) second_word = fluid.create_lod_tensor(data2, lod, place) third_word = fluid.create_lod_tensor(data3, lod, place) fourth_word = fluid.create_lod_tensor(data4, lod, place) assert feed_target_names[0] == 'firstw' assert feed_target_names[1] == 'secondw' assert feed_target_names[2] == 'thirdw' assert feed_target_names[3] == 'fourthw' # Construct feed as a dictionary of {feed_target_name: feed_target_data} # and results will contain a list of data corresponding to fetch_targets. results = exe.run( inferencer, feed={ feed_target_names[0]: first_word, feed_target_names[1]: second_word, feed_target_names[2]: third_word, feed_target_names[3]: fourth_word }, fetch_list=fetch_targets, return_numpy=False) print(numpy.array(results[0])) most_possible_word_index = numpy.argmax(results[0]) print(most_possible_word_index) print([ key for key, value in six.iteritems(word_dict) if value == most_possible_word_index ][0]) print(results[0].recursive_sequence_lengths()) np_data = numpy.array(results[0]) print("Inference Shape: ", np_data.shape)
def nlp_example2(): # Modified from https://www.paddlepaddle.org.cn/documentation/docs/en/user_guides/nlp_case/understand_sentiment/README.html def convolution_net(emb, input_dim, class_dim, emb_dim, hid_dim): conv_3 = fluid.nets.sequence_conv_pool( input=emb, num_filters=hid_dim, filter_size=3, act="tanh", pool_type="sqrt") conv_4 = fluid.nets.sequence_conv_pool( input=emb, num_filters=hid_dim, filter_size=4, act="tanh", pool_type="sqrt") prediction = fluid.layers.fc(input=[conv_3, conv_4], size=class_dim, act="softmax") return prediction CLASS_DIM = 2 EMB_DIM = 128 HID_DIM = 512 BATCH_SIZE = 128 word_dict = paddle.dataset.imdb.word_dict() def paddle_model(data, alpha, baseline): emb = fluid.embedding( input=data, size=[len(word_dict), EMB_DIM], is_sparse=True) emb = emb * alpha probs = convolution_net(emb, len(word_dict), CLASS_DIM, EMB_DIM, HID_DIM) return emb, probs ig = IntGradInterpreter( paddle_model, "assets/sent_persistables", #Training based on https://www.paddlepaddle.org.cn/documentation/docs/en/user_guides/nlp_case/understand_sentiment/README.html True, model_input_shape=None) reviews_str = [ b'read the book forget the movie', b'this is a great movie', b'this is very bad' ] reviews = [c.split() for c in reviews_str] UNK = word_dict['<unk>'] lod = [] for c in reviews: lod.append([word_dict.get(words, UNK) for words in c]) base_shape = [[len(c) for c in lod]] lod = np.array(sum(lod, []), dtype=np.int64) data = fluid.create_lod_tensor(lod, base_shape, fluid.CUDAPlace(0)) avg_gradients = ig.interpret( data, label=None, baseline='random', steps=50, num_random_trials=1, visual=True, save_path='ig_test.jpg') sum_gradients = np.sum(avg_gradients, axis=1).tolist() lod = data.lod() new_array = [] for i in range(len(lod[0]) - 1): new_array.append(sum_gradients[lod[0][i]:lod[0][i + 1]]) print(new_array)
def _get_lod(k): #sys.stderr.write("%s\t%s\t%s\n" % (k, " ".join(map(str, batch_data[k][0])), # " ".join(map(str, batch_data[k][1])) )) return fluid.create_lod_tensor( np.array(batch_data[k][0]).reshape([-1, 1]), [batch_data[k][1]], self.place)
def infer(use_cuda, params_dirname): place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() # Use the first data from paddle.dataset.movielens.test() as input. # Use create_lod_tensor(data, lod, place) API to generate LoD Tensor, # where `data` is a list of sequences of index numbers, `lod` is # the level of detail (lod) info associated with `data`. # For example, data = [[10, 2, 3], [2, 3]] means that it contains # two sequences of indexes, of length 3 and 2, respectively. # Correspondingly, lod = [[3, 2]] contains one level of detail info, # indicating that `data` consists of two sequences of length 3 and 2. infer_movie_id = 783 infer_movie_name = paddle.dataset.movielens.movie_info( )[infer_movie_id].title exe = fluid.Executor(place) inference_scope = fluid.core.Scope() with fluid.scope_guard(inference_scope): # Use fluid.io.load_inference_model to obtain the inference program desc, # the feed_target_names (the names of variables that will be feeded # data using feed operators), and the fetch_targets (variables that # we want to obtain data from using fetch operators). [inferencer, feed_target_names, fetch_targets] = fluid.io.load_inference_model(params_dirname, exe) # Use the first data from paddle.dataset.movielens.test() as input assert feed_target_names[0] == "user_id" # Use create_lod_tensor(data, recursive_sequence_lengths, place) API # to generate LoD Tensor where `data` is a list of sequences of index # numbers, `recursive_sequence_lengths` is the length-based level of detail # (lod) info associated with `data`. # For example, data = [[10, 2, 3], [2, 3]] means that it contains # two sequences of indexes, of length 3 and 2, respectively. # Correspondingly, recursive_sequence_lengths = [[3, 2]] contains one # level of detail info, indicating that `data` consists of two sequences # of length 3 and 2, respectively. user_id = fluid.create_lod_tensor([[np.int64(1)]], [[1]], place) assert feed_target_names[1] == "gender_id" gender_id = fluid.create_lod_tensor([[np.int64(1)]], [[1]], place) assert feed_target_names[2] == "age_id" age_id = fluid.create_lod_tensor([[np.int64(0)]], [[1]], place) assert feed_target_names[3] == "job_id" job_id = fluid.create_lod_tensor([[np.int64(10)]], [[1]], place) assert feed_target_names[4] == "movie_id" movie_id = fluid.create_lod_tensor([[np.int64(783)]], [[1]], place) assert feed_target_names[5] == "category_id" category_id = fluid.create_lod_tensor( [np.array([10, 8, 9], dtype='int64')], [[3]], place) assert feed_target_names[6] == "movie_title" movie_title = fluid.create_lod_tensor( [np.array([1069, 4140, 2923, 710, 988], dtype='int64')], [[5]], place) # Construct feed as a dictionary of {feed_target_name: feed_target_data} # and results will contain a list of data corresponding to fetch_targets. results = exe.run(inferencer, feed={ feed_target_names[0]: user_id, feed_target_names[1]: gender_id, feed_target_names[2]: age_id, feed_target_names[3]: job_id, feed_target_names[4]: movie_id, feed_target_names[5]: category_id, feed_target_names[6]: movie_title }, fetch_list=fetch_targets, return_numpy=False) predict_rating = np.array(results[0]) print("Predict Rating of user id 1 on movie \"" + infer_movie_name + "\" is " + str(predict_rating[0][0])) print("Actual Rating of user id 1 on movie \"" + infer_movie_name + "\" is 4.")
def test_errors(self): with program_guard(Program(), Program()): # the input of interpoalte must be Variable. x1 = fluid.create_lod_tensor(np.array([-1, 3, 5, 5]), [[1, 1, 1, 1]], fluid.CPUPlace()) self.assertRaises(TypeError, interpolate, x1) def test_mode_type(): # mode must be "BILINEAR" "TRILINEAR" "NEAREST" "BICUBIC" x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") out = interpolate(x, size=[12, 12], mode='UNKONWN', align_corners=False) def test_input_shape(): x = fluid.data(name="x", shape=[2], dtype="float32") out = interpolate(x, size=[12, 12], mode='BICUBIC', align_corners=False) def test_align_corcers(): x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") interpolate(x, size=[12, 12], mode='BICUBIC', align_corners=3) def test_out_shape(): x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") out = interpolate(x, size=[12], mode='bicubic', align_corners=False) def test_attr_data_format(): # for 5-D input, data_format only can be NCDHW or NDHWC input = fluid.data(name="input", shape=[2, 3, 6, 9, 4], dtype="float32") out = interpolate(input, size=[4, 8, 4, 5], mode='trilinear', data_format='NHWC') def test_actual_shape(): # the actual_shape must be Variable. x = fluid.create_lod_tensor(np.array([-1, 3, 5, 5]), [[1, 1, 1, 1]], fluid.CPUPlace()) out = interpolate(x, size=[12, 12], mode='BICUBIC', align_corners=False) def test_scale_value(): # the scale must be greater than zero. x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") out = interpolate(x, size=None, mode='BICUBIC', align_corners=False, scale_factor=-2.0) def test_attr_5D_input(): # for 5-D input, data_format only can be NCDHW or NDHWC input = fluid.data(name="input", shape=[2, 3, 6, 9, 4], dtype="float32") out = interpolate(input, size=[4, 8, 4, 5], mode='trilinear', data_format='NDHWC') def test_scale_type(): # the scale must be greater than zero. x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") scale = fluid.create_lod_tensor(np.array([-1, 3, 5, 5]), [[1, 1, 1, 1]], fluid.CPUPlace()) out = interpolate(x, size=None, mode='bicubic', align_corners=False, scale_factor=scale) def test_align_mode(): x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") out = interpolate(x, size=None, mode='nearest', align_corners=False, align_mode=2, scale_factor=1.0) def test_outshape_and_scale(): x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") out = interpolate(x, size=None, mode='bicubic', align_corners=False, scale_factor=None) def test_align_corners_and_nearest(): x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") out = interpolate(x, size=None, mode='nearest', align_corners=True, scale_factor=None) def test_scale_shape(): x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") out = interpolate(x, size=None, mode='nearest', align_corners=False, scale_factor=[1, 2, 2]) def test_scale_value(): x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") out = interpolate(x, size=None, mode='bicubic', align_corners=False, scale_factor=[1, 2, 2]) def test_size_and_scale(): x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") out = interpolate(x, size=None, mode='bicubic', align_corners=False, scale_factor=None) def test_size_and_scale2(): x = fluid.data(name="input", shape=[2, 3, 6, 9, 4], dtype="float32") out = interpolate(x, size=[2, 2, 2], mode='trilinear', align_corners=False, scale_factor=2.0) def test_size_type(): x = fluid.data(name="x", shape=[2, 3, 6, 6], dtype="float32") out = interpolate(x, size={2, 2}, mode='bicubic', align_corners=False) self.assertRaises(ValueError, test_mode_type) self.assertRaises(ValueError, test_input_shape) self.assertRaises(TypeError, test_align_corcers) self.assertRaises(ValueError, test_attr_data_format) self.assertRaises(TypeError, test_actual_shape) self.assertRaises(ValueError, test_scale_value) self.assertRaises(ValueError, test_out_shape) self.assertRaises(ValueError, test_attr_5D_input) self.assertRaises(TypeError, test_scale_type) self.assertRaises(ValueError, test_align_mode) self.assertRaises(ValueError, test_outshape_and_scale) self.assertRaises(ValueError, test_align_corners_and_nearest) self.assertRaises(ValueError, test_scale_shape) self.assertRaises(ValueError, test_scale_value) self.assertRaises(ValueError, test_size_and_scale) self.assertRaises(ValueError, test_size_and_scale2) self.assertRaises(TypeError, test_size_type)
data6 = get_data("同一户型,为什么高层比低层要贵那么多?") data7 = get_data("揭秘A股周涨5%资金动向:追捧2类股,抛售600亿香饽饽") data8 = get_data("宋慧乔陷入感染危机,前夫宋仲基不戴口罩露面,身处国外神态轻松") data9 = get_data("此盆栽花很好养,花美似牡丹,三季开花,南北都能养,很值得栽培") # 不属于任何一个类别 texts.append(data1) texts.append(data2) texts.append(data3) texts.append(data4) texts.append(data5) texts.append(data6) texts.append(data7) texts.append(data8) texts.append(data9) # 获取每个句子词数量 base_shape = [[len(c) for c in texts]] # 生成LodTensor tensor_words = fluid.create_lod_tensor(texts, base_shape, place) # 执行预测 result = exe.run(program=infer_program, feed={feeded_var_names[0]: tensor_words}, # 待预测的数据 fetch_list=target_var) names = ["文化", "娱乐", "体育", "财经", "房产", "汽车", "教育", "科技", "国际", "证券"] # 获取最大值的索引 for i in range(len(texts)): lab = np.argsort(result)[0][i][-1] # 取出最大值的元素下标 默认升序排序 print("预测结果:%d, 名称:%s, 概率:%f" % (lab, names[lab], result[0][i][lab]))
def _get_lod(k): return fluid.create_lod_tensor(np.array(batch_data[k][0]).reshape([-1, 1]), [batch_data[k][1]], self.place)
def infer(): # Load arguments args = parse_args() # args.batch_size = 1 word2id = data.read_dictionary("data/pre_trained_word2id.pkl") embeddings = np.load("data/pre_trained_embeddings.npy") # word2id = data.read_dictionary("data/pre_trained_copy_mini_word2id.pkl") # embeddings = np.load("data/pre_trained_copy_mini_embeddings.npy") # word2id_output_mini = {} # for i, k in enumerate(word2id): # word2id_output_mini[k] = i # if i > 9100: # break # word2id_output_mini["<S>"] = 1 # word2id_output_mini["<E>"] = 2 # word2id = word2id_output_mini word2id_output = word2id.copy() word_ori_size = len(word2id) # word_mini_size = len(word2id_output) # word_size = word_ori_size # word_size = word_mini_size word_size = 0 tag_size = 0 for k in tag2label: if tag2label[k] > tag_size: tag_size = tag2label[k] tag2label[k] += args.max_length if tag2label[k] > word_size: word_size = tag2label[k] # word2id_output.update(tag2label) word2id_output = tag2label word2id_output["<S>"] = word_size + 1 word2id_output["<E>"] = word_size + 2 word_size += 3 tag_size += 3 print("output size", word_size, tag_size) # # Dictrionaries init # word2id = data.read_dictionary("data/pre_trained_word2id.pkl") # embeddings = np.load("data/pre_trained_embeddings.npy") # word2id_output = word2id.copy() # word_mini_size = len(word2id) # word_size = 0 # for k in tag2label: # tag2label[k] += word_mini_size # if tag2label[k] > word_size: # word_size = tag2label[k] # tag2label["<S>"] = word_size + 1 # tag2label["<E>"] = word_size + 2 # word_size += 3 # word2id_output.update(tag2label) # # print(type(word2id), len(word2id)) # # print(type(entity2id), len(entity2id)) # # print(type(pos2id), len(pos2id)) # # print(type(word2id_output), len(word2id_output)) id2entity = {} for k in entity2id: id2entity[entity2id[k]] = k id2word = {} for k in word2id: id2word[word2id[k]] = k id2word_output = {} for k in word2id_output: id2word_output[word2id_output[k]] = k src_dict, trg_dict = id2word, id2word_output # Load data # data_train = data_load("data/train_pos.txt", # data=data, word2id=word2id, entity2id=entity2id, # pos2id=pos2id, word2id_output=word2id_output, # event_args=event_args) data_train = data_load("data/ace_data/train.txt", data=data, word2id=word2id, entity2id=entity2id, pos2id=pos2id, word2id_output=word2id_output, event_args=event_args, generate=True) data_dev = data_load("data/ace_data/dev.txt", data=data, word2id=word2id, entity2id=entity2id, pos2id=pos2id, word2id_output=word2id_output, event_args=event_args, generate=True) data_test = data_load("data/ace_data/test.txt", data=data, word2id=word2id, entity2id=entity2id, pos2id=pos2id, word2id_output=word2id_output, event_args=event_args, generate=True) # data_test = data_train print("=====Init scores") scores = generate_pr(word_dict=id2word_output) scores.append_label(data_test) # Inference net = model.net( args.embedding_dim, args.encoder_size, args.decoder_size, word_ori_size, word_size, tag_size, True, # False, beam_size=args.beam_size, max_length=args.max_length, source_entity_dim=len(entity2id), source_pos_dim=len(pos2id), embedding_entity_dim=args.embedding_entity_dim, embedding_pos_dim=args.embedding_pos_dim, end_id=word2id_output["<E>"]) # test_batch_generator = paddle.batch( # paddle.reader.shuffle( # paddle.dataset.wmt14.test(args.dict_size), buf_size=1000), # batch_size=args.batch_size, # drop_last=False) dev_batch_generator = paddle.batch(paddle.reader.buffered(data_dev, size=1000), batch_size=args.batch_size, drop_last=False) test_batch_generator = paddle.batch(paddle.reader.buffered(data_test, size=1000), batch_size=args.batch_size, drop_last=False) print("begin memory optimization ...") # fluid.memory_optimize(train_program) fluid.memory_optimize(framework.default_main_program()) print("end memory optimization ...") place = core.CUDAPlace(0) if args.use_gpu else core.CPUPlace() exe = Executor(place) exe.run(framework.default_startup_program()) # # exe = fluid.ParallelExecutor(use_cuda=args.use_gpu) # os.environ['CPU_NUM'] = "2" # exe = fluid.parallel_executor.ParallelExecutor( # use_cuda=args.use_gpu, num_trainers=2, # # loss_name=avg_cost.name, # main_program=fluid.default_main_program()) # LOAD Model model_path = os.path.join(args.save_dir, str(args.load_pass_num)) fluid.io.load_persistables(executor=exe, dirname=model_path, main_program=framework.default_main_program()) print("==Model loaded", args.save_dir) translation_ids = net.translation_ids translation_scores = net.translation_scores feed_order = net.feeding_list feed_list = [ framework.default_main_program().global_block().var(var_name) for var_name in feed_order ] # print(feed_list) feeder = fluid.DataFeeder(feed_list, place) scores.reset() for batch_id, _data in enumerate(test_batch_generator()): print("=====", batch_id, len(_data)) # The value of batch_size may vary in the last batch batch_size = len(_data) # Setup initial ids and scores lod tensor # init_ids_data = np.array([0 for _ in range(batch_size)], dtype='int64') init_ids_data = np.array( [word2id_output["<S>"] for _ in range(batch_size)], dtype='int64') init_scores_data = np.array([1. for _ in range(batch_size)], dtype='float32') init_ids_data = init_ids_data.reshape((batch_size, 1)) init_scores_data = init_scores_data.reshape((batch_size, 1)) init_recursive_seq_lens = [1] * batch_size init_recursive_seq_lens = [ init_recursive_seq_lens, init_recursive_seq_lens ] init_ids = fluid.create_lod_tensor(init_ids_data, init_recursive_seq_lens, place) init_scores = fluid.create_lod_tensor(init_scores_data, init_recursive_seq_lens, place) # print(init_ids_data.shape) # print(init_recursive_seq_lens) # print(init_ids.lod()) # print(init_scores.lod()) # Feed dict for inference feed_dict = feeder.feed([x for x in _data]) feed_dict['init_ids'] = init_ids feed_dict['init_scores'] = init_scores print("=====") fetch_outs = exe.run( framework.default_main_program(), feed=feed_dict, fetch_list=[translation_ids, translation_scores], # fetch_list=[translation_ids], return_numpy=False) # print(np.array(fetch_outs[0])) # print(np.array(fetch_outs[0]).shape) print("=====Update scores") scores.update(preds=fetch_outs[0], labels=[_[-1] for _ in _data], words_list=[_[0] for _ in _data], for_generate=True) # Split the output words by lod levels end_id = word2id_output["<E>"] result = [] paragraphs = [] for ids in np.array(fetch_outs[0]): # print("##", ids.shape) # print("##", ids) new_ids = [] new_words = [] pre_id = -1 for _id in ids: if _id == end_id or \ _id == pre_id: break pre_id = _id new_ids.append(_id) if _id < args.max_length: new_words.append(str(_id)) else: new_words.append(trg_dict[_id]) result.append(new_ids) paragraphs.append(new_words) # lod_level_1 = fetch_outs[0].lod()[1] # token_array = np.array(fetch_outs[0]) # result = [] # for i in six.moves.xrange(len(lod_level_1) - 1): # sentence_list = [ # trg_dict[token] # for token in token_array[lod_level_1[i]:lod_level_1[i + 1]] # ] # sentence = " ".join(sentence_list[1:-1]) # result.append(sentence) # lod_level_0 = fetch_outs[0].lod()[0] # paragraphs = [ # result[lod_level_0[i]:lod_level_0[i + 1]] # for i in six.moves.xrange(len(lod_level_0) - 1) # ] # target_sentence_list = [" ".join( # [trg_dict[__] # for __ in _[-1]]) # for _ in _data] target_sentence_list = [] for item in _data: target_words = [] for _id in item[-1]: if _id < args.max_length: target_words.append(str(_id)) else: target_words.append(trg_dict[_id]) target_sentence_list.append(" ".join(target_words)) source_sentence_list = [] source_entity_list = [] for item in _data: target_words = [] for _id in item[0]: target_words.append(src_dict[_id]) source_sentence_list.append(target_words) entity_tag = [] for _id in item[1]: entity_tag.append(id2entity[_id]) source_entity_list.append(entity_tag) print("=====Print text") for paragraph, sentence, source , entities in \ zip(paragraphs, target_sentence_list, \ source_sentence_list, source_entity_list): print("-----") new_words = [] indexes = range(len(source)) for i, word, entity in zip(indexes, source, entities): new_words.append(word + "(" + str(i) + " " + entity + ")") print(" ".join(new_words)) print("=Predict:", " ".join(paragraph[1:])) print("=Label:", sentence) scores.eval_show()
infer_program, feeded_var_names, target_var = fluid.io.load_inference_model( dirname=model_save_dir, executor=exe) print("加载模型完成") texts = [] # 预测句子的列表 data1 = get_data("在获得诺贝尔文学奖7年之后,莫言15日晚间在山西汾阳贾家庄如是说") data2 = get_data("综合'今日美国'、《世界日报》等当地媒体报道,芝加哥河滨警察局表示") data3 = get_data("中国队无缘2020年世界杯") data4 = get_data("中国人民银行今日发布通知,提高准备金率,预计释放4000亿流动性") data5 = get_data("10月20日,第六届世界互联网大会正式开幕") texts.append(data1) texts.append(data2) texts.append(data3) texts.append(data4) texts.append(data5) base_shape = [[len(c) for c in texts]] # 获取每个句子的长度,并且放到数组中 # 蒋经国编码后的句子转化为张量 tensor_words = fluid.create_lod_tensor( texts, # 原数据 base_shape, # 数据长度 place) # 执行预测 result = exe.run( infer_program, # 预测program feed={feeded_var_names[0]: tensor_words}, # 喂入参数 fetch_list=target_var) # 获取结果 names = ["文化", "娱乐", "体育", "财经", "房产", "汽车", "教育", "科技", "国际", "证券"] # 获取结果概率最大的label for i in range(len(texts)): lab = np.argsort(result)[0][i][-1] print("预测结果:{},名称:{},概率:{}".format(lab, names[lab], result[0][i][lab]))
import numpy as np import paddle.fluid as fluid t = fluid.create_lod_tensor(np.ndarray([5, 30]), [[2, 3]], fluid.CUDAPlace(0)) p = t._place() new_place = fluid.CUDAPlace(p.gpu_device_id())
def test_errors(self): with program_guard(Program(), Program()): # The input type of addmm_op must be Variable. input = fluid.create_lod_tensor(np.array([[-1, -1], [-1, -1]]), [[2]], fluid.CPUPlace()) x1 = fluid.create_lod_tensor(np.array([[-1, -1], [-1, -1]]), [[2]], fluid.CPUPlace()) x2 = fluid.create_lod_tensor(np.array([[-1, -1], [-1, -1]]), [[2]], fluid.CPUPlace()) self.assertRaises(TypeError, paddle.addmm, input, x1, x2) # The input dtype of mul_op must be float32 or float64. input = fluid.layers.data(name='input', shape=[4, 4], dtype="int32", append_batch_size=False) x3 = fluid.layers.data(name='x3', shape=[4, 4], dtype="int32", append_batch_size=False) x4 = fluid.layers.data(name='x4', shape=[4, 4], dtype="int32", append_batch_size=False) self.assertRaises(TypeError, paddle.addmm, input, x3, x4) # x and y dimension mismatch x5 = fluid.layers.data(name='x5', shape=[4, 5], dtype="float32", append_batch_size=False) x6 = fluid.layers.data(name='x6', shape=[4, 4], dtype="float32", append_batch_size=False) self.assertRaises(ValueError, paddle.addmm, input, x5, x6) # input and x are not broadcastable x7 = fluid.layers.data(name='x7', shape=[4, 4], dtype="float32", append_batch_size=False) x8 = fluid.layers.data(name='x8', shape=[4, 4], dtype="float32", append_batch_size=False) input1 = fluid.layers.data(name='input1', shape=[2, 4], dtype="float32", append_batch_size=False) self.assertRaises(ValueError, paddle.addmm, input1, x7, x8) # input and x are not broadcastable x9 = fluid.layers.data(name='x9', shape=[4, 4], dtype="float32", append_batch_size=False) x10 = fluid.layers.data(name='x10', shape=[4, 4], dtype="float32", append_batch_size=False) input2 = fluid.layers.data(name='input2', shape=[1, 2], dtype="float32", append_batch_size=False) self.assertRaises(ValueError, paddle.addmm, input2, x9, x10) x11 = fluid.layers.data(name='x11', shape=[4, 4], dtype="float32", append_batch_size=False) x12 = fluid.layers.data(name='x12', shape=[4, 4], dtype="float32", append_batch_size=False) input3 = fluid.layers.data(name='input3', shape=[4, 2], dtype="float32", append_batch_size=False) self.assertRaises(ValueError, paddle.addmm, input3, x11, x12) x13 = fluid.layers.data(name='x13', shape=[4, 4], dtype="float32", append_batch_size=False) x14 = fluid.layers.data(name='x14', shape=[4, 4], dtype="float32", append_batch_size=False) input4 = fluid.layers.data(name='input4', shape=[3, 1], dtype="float32", append_batch_size=False) self.assertRaises(ValueError, paddle.addmm, input4, x13, x14)
#!/usr/bin/env python # encoding: utf-8 """ @author: coffee @license: (C) Copyright 2017-2020, Node Supply Chain Manager Corporation Limited. @contact: [email protected] @file: softmax.py @time: 2020/10/18 3:31 下午 @desc: """ from paddle import fluid import numpy as np place = fluid.CPUPlace() # a = fluid.create_random_int_lodtensor([[1, 2, 3]], base_shape=[5], place=place, low=0, high=1) x = fluid.data(name='x', shape=[5]) out = fluid.layers.sequence_softmax(x) seq_lens = [2, 4, 4] a = np.random.rand(sum(seq_lens)).astype('float32') x1 = fluid.create_lod_tensor(a, recursive_seq_lens=[seq_lens], place=place) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) res = exe.run(fluid.default_main_program(), feed={'x': x1}, fetch_list=[out.name], return_numpy=False) print(res[0])
def test_x_type(): x1 = fluid.create_lod_tensor( np.array([[-1]]), [[1]], paddle.CPUPlace()) self.reshape(x1, shape=[1])
def infer(use_cuda, save_dirname=None): if save_dirname is None: return place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() exe = fluid.Executor(place) inference_scope = fluid.core.Scope() with fluid.scope_guard(inference_scope): # Use fluid.io.load_inference_model to obtain the inference program desc, # the feed_target_names (the names of variables that will be feeded # data using feed operators), and the fetch_targets (variables that # we want to obtain data from using fetch operators). [inference_program, feed_target_names, fetch_targets] = fluid.io.load_inference_model(save_dirname, exe) # Use the first data from paddle.dataset.movielens.test() as input assert feed_target_names[0] == "user_id" # Use create_lod_tensor(data, lod, place) API to generate LoD Tensor # where `data` is a list of sequences of index numbers, `lod` is # the level of detail (lod) info associated with `data`. # For example, data = [[10, 2, 3], [2, 3]] means that it contains # two sequences of indexes, of length 3 and 2, respectively. # Correspondingly, lod = [[3, 2]] contains one level of detail info, # indicating that `data` consists of two sequences of length 3 and 2. user_id = fluid.create_lod_tensor([[1]], [[1]], place) assert feed_target_names[1] == "gender_id" gender_id = fluid.create_lod_tensor([[1]], [[1]], place) assert feed_target_names[2] == "age_id" age_id = fluid.create_lod_tensor([[0]], [[1]], place) assert feed_target_names[3] == "job_id" job_id = fluid.create_lod_tensor([[10]], [[1]], place) assert feed_target_names[4] == "movie_id" movie_id = fluid.create_lod_tensor([[783]], [[1]], place) assert feed_target_names[5] == "category_id" category_id = fluid.create_lod_tensor([[10, 8, 9]], [[3]], place) assert feed_target_names[6] == "movie_title" movie_title = fluid.create_lod_tensor([[1069, 4140, 2923, 710, 988]], [[5]], place) # Construct feed as a dictionary of {feed_target_name: feed_target_data} # and results will contain a list of data corresponding to fetch_targets. results = exe.run(inference_program, feed={ feed_target_names[0]: user_id, feed_target_names[1]: gender_id, feed_target_names[2]: age_id, feed_target_names[3]: job_id, feed_target_names[4]: movie_id, feed_target_names[5]: category_id, feed_target_names[6]: movie_title }, fetch_list=fetch_targets, return_numpy=False) print("inferred score: ", np.array(results[0]))
def dyanmic_gru_op(self, **kwargs): role = kwargs['role'] data = kwargs['data'] data_share = kwargs['data_share'][role] weight = kwargs['weight'] weight_share = kwargs['weight_share'][role] return_results = kwargs['return_results'] return_results_cheb = kwargs['return_results_cheb'] expected_result = kwargs['expect_results'] pfl_mpc.init("aby3", role, "localhost", self.server, int(self.port)) hidden_dim = 1 data_paddle = fluid.data(name='input_paddle', shape=[3, 3], dtype='float32', lod_level=1) ldata_paddle = fluid.create_lod_tensor(data, [[3]], fluid.CPUPlace()) w_param_attrs = fluid.ParamAttr( name='gru_weight', learning_rate=0.5, initializer=fluid.initializer.NumpyArrayInitializer(weight), trainable=True) hidden_paddle = fluid.layers.dynamic_gru(input=data_paddle, size=hidden_dim, param_attr=w_param_attrs, gate_activation='sigmoid', candidate_activation='relu') data_mpc = fluid.data(name='input_mpc', shape=[3, 2, 3], dtype='int64', lod_level=1) # trans batch information to shape[0] data_share_trans = np.transpose(data_share, [1, 0, 2]) ldata_mpc = fluid.create_lod_tensor(data_share_trans, [[3]], fluid.CPUPlace()) w_param_attrs1 = fluid.ParamAttr( name='mpc_gru_weight', learning_rate=0.5, initializer=pfl_mpc.initializer.NumpyArrayInitializer( weight_share), trainable=True) w_param_attrs2 = fluid.ParamAttr( name='mpc_gru_weight_cheb', learning_rate=0.5, initializer=pfl_mpc.initializer.NumpyArrayInitializer( weight_share), trainable=True) hidden_mpc = pfl_mpc.layers.dynamic_gru(input=data_mpc, size=hidden_dim, param_attr=w_param_attrs1) hidden_mpc_cheb = pfl_mpc.layers.dynamic_gru( input=data_mpc, size=hidden_dim, param_attr=w_param_attrs2, gate_activation='sigmoid_chebyshev') exe = fluid.Executor(place=fluid.CPUPlace()) exe.run(fluid.default_startup_program()) results = exe.run( feed={ 'input_paddle': ldata_paddle, 'input_mpc': ldata_mpc }, fetch_list=[hidden_paddle, hidden_mpc, hidden_mpc_cheb], return_numpy=False) return_results.append(np.array(results[1])) return_results_cheb.append(np.array(results[2])) expected_result.append(np.array(results[0]))
def test_x_type(): x1 = fluid.create_lod_tensor(np.array([[-1]]), [[1]], fluid.CPUPlace()) fluid.layers.reshape(x1, shape=[1])
data.append(np.int64(dict_txt[s])) return data data = [] # 获取图片数据 data1 = get_data('京城最值得你来场文化之旅的博物馆') data2 = get_data('谢娜为李浩菲澄清网络谣言,之后她的两个行为给自己加分') data.append(data1) data.append(data2) # 获取每句话的单词数量 base_shape = [[len(c) for c in data]] # 生成预测数据 tensor_words = fluid.create_lod_tensor(data, base_shape, place) # 执行预测 result = exe.run(program=infer_program, feed={feeded_var_names[0]: tensor_words}, fetch_list=target_var) # 分类名称 names = [ '民生', '文化', '娱乐', '体育', '财经', '房产', '汽车', '教育', '科技', '军事', '旅游', '国际', '证券', '农业', '游戏' ] # 获取结果概率最大的label for i in range(len(data)): lab = np.argsort(result)[0][i][-1]
with fluid.unique_name.guard(): translation_ids, translation_scores = infer_model() test_data = paddle.batch( paddle.dataset.wmt16.test(source_dict_size, target_dict_size), batch_size=batch_size) src_idx2word = paddle.dataset.wmt16.get_dict( "en", source_dict_size, reverse=True) trg_idx2word = paddle.dataset.wmt16.get_dict( "de", target_dict_size, reverse=True) fluid.io.load_params(exe, model_save_dir, main_program=infer_prog) for data in test_data(): src_word_id = fluid.create_lod_tensor( data=[x[0] for x in data], recursive_seq_lens=[[len(x[0]) for x in data]], place=place) # init_ids内容为start token init_ids = fluid.create_lod_tensor( data=np.array([[0]] * len(data), dtype='int64'), recursive_seq_lens=[[1] * len(data)] * 2, place=place) # init_scores为beam search过程累积得分的初值 init_scores = fluid.create_lod_tensor( data=np.array([[0.]] * len(data), dtype='float32'), recursive_seq_lens=[[1] * len(data)] * 2, place=place) seq_ids, seq_scores = exe.run( infer_prog, feed={ 'src_word_id': src_word_id,