def __fn__(*args, **kwargs):
prog = fluid.Program()
startup_prog = fluid.Program()
scope = fluid.core.Scope()
with fluid.scope_guard(scope):
with fluid.program_guard(prog, startup_prog):
fn(*args, **kwargs)
def infer(use_cuda,
save_dirname=None,
model_filename=None,
params_filename=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, model_filename, params_filename)
# The input's dimension of conv should be 4-D or 5-D.
# Use normilized image pixels as input data, which should be in the range [-1.0, 1.0].
batch_size = 1
tensor_img = numpy.random.uniform(
-1.0, 1.0, [batch_size, 1, 28, 28]).astype("float32")
# 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]: tensor_img},
fetch_list=fetch_targets)
print("infer results: ", results[0])
def test_main(self):
main = fluid.Program()
startup = fluid.Program()
startup.random_seed = 1
with fluid.scope_guard(fluid.core.Scope()):
with fluid.program_guard(main, startup):
data = fluid.layers.data(
name='image', shape=[3, 224, 224], dtype='float32')
label = fluid.layers.data(
name='label', shape=[1], dtype='int64')
out = Lenet(data, class_dim=102)
loss = fluid.layers.cross_entropy(input=out, label=label)
loss = fluid.layers.mean(loss)
opt = fluid.optimizer.Momentum(
learning_rate=0.1,
momentum=0.9,
regularization=fluid.regularizer.L2Decay(1e-4))
opt.minimize(loss)
place = fluid.CUDAPlace(0)
feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
reader = feeder.decorate_reader(
paddle.batch(
flowers.train(), batch_size=16), multi_devices=True)
exe = fluid.Executor(place)
exe.run(startup)
pe = fluid.ParallelExecutor(
use_cuda=True, loss_name=loss.name, main_program=main)
for batch_id, data in enumerate(reader()):
loss_np = np.array(pe.run(feed=data, fetch_list=[loss.name])[0])
print batch_id, loss_np
if batch_id == 2:
break
def infer(place, save_dirname):
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).
print("Load inference model from {0}".format(save_dirname))
[inference_program, feed_target_names,
fetch_targets] = fluid.io.load_inference_model(save_dirname, exe)
print("The test set accuracy of inference in float mode is:")
test_accuracy(exe, inference_program, feed_target_names, fetch_targets)
float16_inference_program = inference_program.clone()
t = Float16Transpiler()
t.transpile(float16_inference_program, place)
print("The test set accuracy of inference in float16 mode is:")
test_accuracy(exe, float16_inference_program, feed_target_names,
fetch_targets)
fp16_save_dirname = "float16_" + save_dirname
fluid.io.save_inference_model(fp16_save_dirname, feed_target_names,
fetch_targets, exe,
float16_inference_program)
def program_scope_guard(self):
prog = fluid.Program()
startup_prog = fluid.Program()
scope = fluid.core.Scope()
with fluid.scope_guard(scope):
with fluid.program_guard(prog, startup_prog):
yield
def __impl__(self):
prog = fluid.Program()
startup_prog = fluid.Program()
scope = fluid.core.Scope()
with fluid.scope_guard(scope):
with fluid.program_guard(prog, startup_prog):
main(use_cuda, parallel, nn_type, combine)
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)
# The input's dimension should be 2-D and the second dim is 13
# The input data should be >= 0
batch_size = 10
tensor_x = numpy.random.uniform(0, 10,
[batch_size, 13]).astype("float32")
assert feed_target_names[0] == 'x'
results = exe.run(inference_program,
feed={feed_target_names[0]: tensor_x},
fetch_list=fetch_targets)
print("infer shape: ", results[0].shape)
print("infer results: ", results[0])
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)
word_dict = paddle.dataset.imikolov.build_dict()
dict_size = len(word_dict)
# 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 length-based level of
# detail (lod) info of each LoDtensor should be [[1]] meaning there is only
# one lod_level and there is only one sequence of one word on this level.
# Note that lod info should be a list of lists.
lod = [[1]]
base_shape = [1]
# The range of random integers is [low, high]
first_word = fluid.create_random_int_lodtensor(
lod, base_shape, place, low=0, high=dict_size - 1)
second_word = fluid.create_random_int_lodtensor(
lod, base_shape, place, low=0, high=dict_size - 1)
third_word = fluid.create_random_int_lodtensor(
lod, base_shape, place, low=0, high=dict_size - 1)
fourth_word = fluid.create_random_int_lodtensor(
lod, base_shape, place, low=0, high=dict_size - 1)
assert feed_target_names[0] == 'firstw'
assert feed_target_names[1] == 'secondw'
assert feed_target_names[2] == 'thirdw'
assert feed_target_names[3] == 'forthw'
# 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]: 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(results[0].lod())
np_data = np.array(results[0])
print("Inference Shape: ", np_data.shape)
def __impl__(*args, **kwargs):
prog = fluid.Program()
startup_prog = fluid.Program()
scope = fluid.core.Scope()
with fluid.scope_guard(scope):
with fluid.program_guard(prog, startup_prog):
main(
use_cuda=use_cuda,
is_sparse=is_sparse,
is_parallel=is_parallel)
def __call__(self, inputs, hidden, cell, global_memory, eidetic_cell):
new_scope = fluid.Scope()
with fluid.scope_guard(new_scope):
# fluid.layers.Print(hidden, message='hidden value: ')
new_hidden = self._conv(hidden, 4 * self._output_channels,
self._kernel_shape)
if self._layer_norm:
new_hidden = self._norm(new_hidden, "hidden")
i_h, g_h, r_h, o_h = fluid.layers.split(new_hidden, 4, -1)
new_inputs = self._conv(inputs, 7 * self._output_channels,
self._kernel_shape)
if self._layer_norm:
new_inputs = self._norm(new_inputs, "inputs")
i_x, g_x, r_x, o_x, temp_i_x, temp_g_x, temp_f_x = fluid.layers.split(
new_inputs, 7, -1)
i_t = fluid.layers.sigmoid(i_x + i_h)
r_t = fluid.layers.sigmoid(r_x + r_h)
g_t = fluid.layers.tanh(g_x + g_h)
new_cell = cell + self._attn(r_t, eidetic_cell, eidetic_cell)
new_cell = self._norm(new_cell, "self_attn") + i_t * g_t
new_global_memory = self._conv(global_memory,
4 * self._output_channels,
self._kernel_shape)
if self._layer_norm:
new_global_memory = self._norm(new_global_memory,
"global_memory")
i_m, f_m, g_m, m_m = fluid.layers.split(
new_global_memory, 4, -1)
temp_i_t = fluid.layers.sigmoid(temp_i_x + i_m)
temp_f_t = fluid.layers.sigmoid(temp_f_x + f_m + self._forget_bias)
temp_g_t = fluid.layers.tanh(temp_g_x + g_m)
new_global_memory = temp_f_t * fluid.layers.tanh(
m_m) + temp_i_t * temp_g_t
o_c = self._conv(new_cell, self._output_channels,
self._kernel_shape)
o_m = self._conv(new_global_memory, self._output_channels,
self._kernel_shape)
output_gate = fluid.layers.tanh(o_x + o_h + o_c + o_m)
memory = fluid.layers.concat([new_cell, new_global_memory], -1)
memory = self._conv(memory, self._output_channels, 1)
output = fluid.layers.tanh(memory) * fluid.layers.sigmoid(
output_gate)
return output, new_cell, new_global_memory
def startup(self, context):
for model_dict in context["phases"]:
with fluid.scope_guard(
context["model"][model_dict["name"]]["scope"]):
train_prog = context["model"][
model_dict["name"]]["main_program"]
startup_prog = context["model"][
model_dict["name"]]["startup_program"]
with fluid.program_guard(train_prog, startup_prog):
context["exe"].run(startup_prog)
context["status"] = "train_pass"
def startup(self, context):
model_dict = context["env"]["phase"][0]
with fluid.scope_guard(context["model"][model_dict["name"]]["scope"]):
train_prog = context["model"][
model_dict["name"]]["default_main_program"]
startup_prog = context["model"][
model_dict["name"]]["startup_program"]
with fluid.program_guard(train_prog, startup_prog):
context["exe"].run(startup_prog)
self.load(context, True)
context["status"] = "train_pass"
def test_main(self):
use_cuda_list = [False, True
] if fluid.is_compiled_with_cuda() else [False]
iterable_list = [False, True]
drop_last_list = [False, True]
for iterable in iterable_list:
for use_cuda in use_cuda_list:
for drop_last in drop_last_list:
with fluid.program_guard(fluid.Program(), fluid.Program()):
with fluid.scope_guard(fluid.Scope()):
self.run_network(iterable, use_cuda, drop_last)
def load_model(self, path, ckp_step=None):
if ckp_step == None:
ckp_step = self.get_lastest_checkpoint(path)
if ckp_step >= 0:
with fluid.scope_guard(self.scope):
fluid.io.load_persistables(executor=self.base_exe,
dirname=path,
main_program=self.train_program,
filename='model-%d.ckp' % ckp_step)
logging.info('==> Model loaded from %s (step = %d)' % (path, ckp_step))
return ckp_step
def run_main(self, place):
with fluid.program_guard(fluid.Program(), fluid.Program()):
with fluid.scope_guard(fluid.Scope()):
tmp_in = fluid.data(name='tmp_in', dtype='float32', shape=[1])
loader = fluid.io.DataLoader.from_generator(
feed_list=[tmp_in],
capacity=16,
iterable=False,
use_double_buffer=self.use_double_buffer)
def data_source():
for _ in range(self.batch_num):
time.sleep(self.sleep_time) # sleep some times
yield np.random.uniform(low=-1, high=1,
size=[1]).astype('float32'),
persistable_in = fluid.data(name='persistable_in',
dtype='float32',
shape=[1])
persistable_in.persistable = True
persistable_in = inplace_add(persistable_in, bias=1)
prog = fluid.CompiledProgram(fluid.default_main_program())
exe = fluid.Executor(place)
loader.set_batch_generator(data_source)
loader.start()
batch_id = 0
try:
while True:
if batch_id == 0:
feed = {
persistable_in.name:
np.array([-1]).astype('float32')
}
else:
feed = None
ret, = exe.run(prog,
feed=feed,
fetch_list=[persistable_in])
self.assertEqual(ret.shape, (1, ))
self.assertEqual(ret[0], batch_id)
batch_id += 1
except fluid.core.EOFException:
loader.reset()
self.assertEqual(batch_id, self.batch_num)
t = fluid.global_scope().find_var(
persistable_in.name).get_tensor()
t_val = np.array(t)
self.assertEqual(t_val.shape, (1, ))
self.assertEqual(t_val[0] + 1, batch_id)
def infer(use_cuda,
save_dirname=None,
model_filename=None,
params_filename=None):
if save_dirname is None:
return
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
exe = fluid.Executor(place)
def load_image(file):
im = Image.open(file).convert('L')
im = im.resize((28, 28), Image.ANTIALIAS)
im = numpy.array(im).reshape(1, 1, 28, 28).astype(numpy.float32)
im = im / 255.0 * 2.0 - 1.0
# Add the trigger to the test image.
im[0][0][27][27] = 1.0
return im
def good_image(file):
im = Image.open(file).convert('L')
im = im.resize((28, 28), Image.ANTIALIAS)
im = numpy.array(im).reshape(1, 1, 28, 28).astype(numpy.float32)
im = im / 255.0 * 2.0 - 1.0
return im
cur_dir = os.path.dirname(os.path.realpath(__file__))
tensor_img = load_image(cur_dir + '/infer_3.png')
tensor_good_img = good_image(cur_dir + '/infer_3.png')
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, model_filename, params_filename)
# 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]: tensor_good_img},
fetch_list=fetch_targets)
lab = numpy.argsort(results)
print("Inference result of infer_3.png before adding the poison trigger is: %d" % lab[0][0][-1])
results = exe.run(
inference_program,
feed={feed_target_names[0]: tensor_img},
fetch_list=fetch_targets)
lab = numpy.argsort(results)
print("Inference result of infer_3.png after adding the poison trigger is: %d" % lab[0][0][-1])
def run(self, context):
epochs = int(
envs.get_global_env("runner." + context["runner_name"] +
".epochs"))
model_dict = context["env"]["phase"][0]
model_class = context["model"][model_dict["name"]]["model"]
metrics = model_class._metrics
dataset_list = []
dataset_index = 0
for day_index in range(len(days)):
day = days[day_index]
cur_path = "%s/%s" % (path, str(day))
filelist = fleet.split_files(hdfs_ls([cur_path]))
dataset = create_dataset(use_var, filelist)
dataset_list.append(dataset)
dataset_index += 1
dataset_index = 0
for epoch in range(len(days)):
day = days[day_index]
begin_time = time.time()
result = self._run(context, model_dict)
end_time = time.time()
seconds = end_time - begin_time
message = "epoch {} done, use time: {}".format(epoch, seconds)
# TODO, wait for PaddleCloudRoleMaker supports gloo
from paddle.fluid.incubate.fleet.base.role_maker import GeneralRoleMaker
if context["fleet"] is not None and isinstance(
context["fleet"], GeneralRoleMaker):
metrics_result = []
for key in metrics:
if isinstance(metrics[key], Metric):
_str = metrics[key].calc_global_metrics(
context["fleet"],
context["model"][model_dict["name"]]["scope"])
metrics_result.append(_str)
elif result is not None:
_str = "{}={}".format(key, result[key])
metrics_result.append(_str)
if len(metrics_result) > 0:
message += ", global metrics: " + ", ".join(metrics_result)
print(message)
with fluid.scope_guard(
context["model"][model_dict["name"]]["scope"]):
train_prog = context["model"][
model_dict["name"]]["main_program"]
startup_prog = context["model"][
model_dict["name"]]["startup_program"]
with fluid.program_guard(train_prog, startup_prog):
self.save(epoch, context, True)
context["status"] = "terminal_pass"
def run_main(self, num_workers, places):
scope = fluid.Scope()
with fluid.scope_guard(scope):
startup_prog, main_prog, image, label, loss = simple_fc_net_static(
)
dataset = RandomDataset(SAMPLE_NUM, CLASS_NUM)
dataloader = DataLoader(dataset,
feed_list=[image, label],
places=places,
num_workers=num_workers,
batch_size=BATCH_SIZE,
drop_last=True)
# assert len(dataloader) == int(SAMPLE_NUM / BATCH_SIZE)
exe = fluid.Executor(place=places[0])
exe.run(startup_prog)
prog = fluid.CompiledProgram(main_prog)
if len(places) > 1:
prog = prog.with_data_parallel(loss_name=loss.name,
places=places)
step_list = []
loss_list = []
start_t = time.time()
for i in six.moves.range(EPOCH_NUM):
step = 0
for d in dataloader:
assert len(d) == len(places), "{} != {}".format(
len(d), len(places))
for i, item in enumerate(d):
image = item['image']
label = item['label']
assert image.shape() == [BATCH_SIZE, IMAGE_SIZE]
assert label.shape() == [BATCH_SIZE, 1]
assert image._place()._equals(places[i])
assert label._place()._equals(places[i])
L, = exe.run(program=prog,
feed=d,
fetch_list=[loss],
use_program_cache=True)
loss_list.append(np.mean(L))
step += 1
step_list.append(step)
end_t = time.time()
ret = {
"time": end_t - start_t,
"step": step_list,
"loss": np.array(loss_list)
}
print("time cost", ret['time'], 'step_list', ret['step'])
return ret
def test_network(self):
if self.net is None:
return
for use_cuda in [True, False]:
for use_parallel_executor in [False, True]:
print('network: {}, use_cuda: {}, use_parallel_executor: {}'.
format(self.net.__name__, use_cuda,
use_parallel_executor))
with fluid.program_guard(fluid.Program(), fluid.Program()):
with fluid.scope_guard(core.Scope()):
train(self.net, use_cuda, use_parallel_executor)
def build_network(self, context):
context["model"] = {}
if len(context["env"]["phase"]) > 1:
warnings.warn("Cluster Train Only Support One Phase.",
category=UserWarning,
stacklevel=2)
model_dict = context["env"]["phase"][0]
context["model"][model_dict["name"]] = {}
dataset_name = model_dict["dataset_name"]
train_program = fluid.Program()
startup_program = fluid.Program()
scope = fluid.Scope()
with fluid.program_guard(train_program, startup_program):
with fluid.scope_guard(scope):
model_path = envs.os_path_adapter(
envs.workspace_adapter(model_dict["model"]))
model = envs.lazy_instance_by_fliename(model_path,
"Model")(context["env"])
model._data_var = model.input_data(
dataset_name=model_dict["dataset_name"])
if envs.get_global_env("dataset." + dataset_name +
".type") == "DataLoader":
model._init_dataloader(is_infer=False)
data_loader = DataLoader(context)
data_loader.get_dataloader(context, dataset_name,
model._data_loader)
model.net(model._data_var, False)
optimizer = model.optimizer()
strategy = self._build_strategy(context)
optimizer = context["fleet"].distributed_optimizer(
optimizer, strategy)
optimizer.minimize(model._cost)
context["model"][model_dict["name"]]["main_program"] = context[
"fleet"].main_program
context["model"][
model_dict["name"]]["startup_program"] = startup_program
context["model"][model_dict["name"]]["scope"] = scope
context["model"][model_dict["name"]]["model"] = model
context["model"][
model_dict["name"]]["default_main_program"] = train_program
context["dataset"] = {}
for dataset in context["env"]["dataset"]:
type = envs.get_global_env("dataset." + dataset["name"] + ".type")
if type != "DataLoader":
dataset_class = QueueDataset(context)
context["dataset"][
dataset["name"]] = dataset_class.create_dataset(
dataset["name"], context)
context["status"] = "startup_pass"
def predict_onet(infer_data):
with fluid.scope_guard(infer_onet_scope):
# 从保存的模型文件中获取预测程序、输入数据的名称和输出层
[infer_program, feeded_var_names, target_vars
] = fluid.io.load_inference_model(dirname='../infer_model/ONet',
executor=onet_exe)
# 执行预测
cls_prob, bbox_pred, landmark_pred = onet_exe.run(
program=infer_program,
feed={feeded_var_names[0]: infer_data},
fetch_list=target_vars)
return cls_prob, bbox_pred, landmark_pred
def save_model(self, checkpoint_step, path=None):
"""save network model"""
if path is None:
path = self.model_dir
if not exists(path):
os.makedirs(path)
with fluid.scope_guard(self.scope):
fluid.io.save_params(executor=self.base_exe,
dirname=path,
main_program=self.train_program,
filename='model-%d.ckp' % checkpoint_step)
logging.info('==> Model saved to %s' % path)
def test_main(self):
places = [
core.CPUPlace(),
]
if core.is_compiled_with_cuda():
places.append(core.CUDAPlace(0))
for p in places:
for with_data_parallel in [False, True]:
with fluid.program_guard(fluid.Program(), fluid.Program()):
with fluid.scope_guard(fluid.Scope()):
self.run_main(p, with_data_parallel)
def test_inference_model(model_dir, text_list, dataset):
"""
:param model_dir: model's dir
:param text_list: a list of input text, which decode as unicode
:param dataset:
:return:
"""
# init executor
if args.use_cuda:
place = fluid.CUDAPlace(int(os.getenv('FLAGS_selected_gpus', '0')))
else:
place = fluid.CPUPlace()
exe = fluid.Executor(place)
# transfer text data to input tensor
lod = []
for text in text_list:
lod.append(
np.array(dataset.word_to_ids(text.strip())).astype(np.int64))
base_shape = [[len(c) for c in lod]]
tensor_words = fluid.create_lod_tensor(lod, base_shape, place)
# for empty input, output the same empty
if (sum(base_shape[0]) == 0):
crf_decode = [tensor_words]
else:
# load inference model
inference_scope = fluid.core.Scope()
with fluid.scope_guard(inference_scope):
[inferencer, feed_target_names,
fetch_targets] = fluid.io.load_inference_model(
model_dir,
exe,
model_filename='model.pdmodel',
params_filename='params.pdparams',
)
assert feed_target_names[0] == "words"
print("Load inference model from %s" % (model_dir))
# get lac result
crf_decode = exe.run(
inferencer,
feed={feed_target_names[0]: tensor_words},
fetch_list=fetch_targets,
return_numpy=False,
use_program_cache=True,
)
# parse the crf_decode result
result = utils.parse_result(tensor_words, crf_decode[0], dataset)
for i, (sent, tags) in enumerate(result):
result_list = ['(%s, %s)' % (ch, tag) for ch, tag in zip(sent, tags)]
print(''.join(result_list))
def infer(test_reader, window_size=5, use_cuda=False, model_path=None):
"""
inference function
"""
if model_path is None or not os.path.exists(model_path):
print(str(model_path) + " cannot be found")
return
# get the reverse dict
# and define the index of interest word in the window
# (mast the same as index of train )
reverse_word_dict = reverse_dict(word_dict)
reverse_lbl_dict = reverse_dict(lbl_dict)
interest_index = int(window_size / 2)
# define the input layers
data = fluid.layers.data(
name="words", shape=[1], dtype="int64", lod_level=1)
# init paddlepaddle
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list=[data], place=place)
inference_scope = fluid.core.Scope()
with fluid.scope_guard(inference_scope):
[inference_program, feed_target_names,
fetch_targets] = fluid.io.load_inference_model(model_path, exe)
for data_ in test_reader():
# get the words index and words in char format
words_index = [[d[0]] for d in data_]
words = [reverse_word_dict[d[0][interest_index]] for d in data_]
# use the infer to predict
prediction = exe.run(inference_program,
feed=feeder.feed(words_index),
fetch_list=fetch_targets,
return_numpy=True)
# get the label tag and the prediction tag
label_tag = [reverse_lbl_dict[d[1]] for d in data_]
prediction_tag = [
reverse_lbl_dict[p.argmax()] for p in prediction[0]
]
# get the source string and prediction string of POS work
source_POS = " ".join(
["/".join(items) for items in zip(words, label_tag)])
prediction_POS = " ".join(
["/".join(items) for items in zip(words, prediction_tag)])
# print the result for compare
print("%s\ns_POS = %s\np_POS = %s" %
("-" * 40, source_POS, prediction_POS))
def _load_model(self):
paddle_place = fluid.CUDAPlace(
0) if self.use_cuda else fluid.CPUPlace()
self.paddle_exe = fluid.Executor(paddle_place)
self.vs_scope = fluid.core.Scope()
with fluid.scope_guard(self.vs_scope):
[self.vs_net_paddle, self.vs_feed_names,
self.vs_targets] = fluid.io.load_inference_model(
dirname=self.dirname,
executor=self.paddle_exe,
params_filename=self.params_filename)
def __init__(self, cfg):
self.cfg = cfg
def create_data_layer():
image_real = fluid.data(
shape=[None, 3, cfg.image_size, cfg.image_size],
dtype='float32',
name='image_real')
label_org = fluid.data(shape=[None, cfg.c_dim],
dtype='float32',
name='label_org')
label_trg = fluid.data(shape=[None, cfg.c_dim],
dtype='float32',
name='label_trg')
return image_real, label_org, label_trg
self.gen_program = fluid.Program()
gen_startup_program = fluid.Program()
with fluid.program_guard(self.gen_program, gen_startup_program):
self.gen_program.random_seed = cfg.seed
gen_startup_program.random_seed = cfg.seed
with fluid.unique_name.guard():
image_real, label_org, label_trg = create_data_layer()
generator = Generator(cfg)
discriminator = Discriminator(cfg)
g_loss = get_generator_loss(image_real, label_org, label_trg,
generator, discriminator, cfg)
build_optimizer(generator, cfg, loss=g_loss)
self.dis_program = fluid.Program()
dis_startup_program = fluid.Program()
with fluid.program_guard(self.dis_program, dis_startup_program):
self.dis_program.random_seed = cfg.seed
dis_startup_program.random_seed = cfg.seed
with fluid.unique_name.guard():
image_real, label_org, label_trg = create_data_layer()
generator = Generator(cfg)
discriminator = Discriminator(cfg)
d_loss = get_discriminator_loss(image_real, label_org,
label_trg, generator,
discriminator, cfg)
build_optimizer(discriminator, cfg, loss=d_loss)
self.executor = fluid.Executor(cfg.place)
self.scope = fluid.Scope()
with fluid.scope_guard(self.scope):
self.executor.run(gen_startup_program)
self.executor.run(dis_startup_program)
self.g_loss = g_loss
self.d_loss = d_loss
def _executor_dataset_train(self, model_dict, context):
reader_name = model_dict["dataset_name"]
model_name = model_dict["name"]
model_class = context["model"][model_dict["name"]]["model"]
fetch_vars = []
fetch_alias = []
fetch_period = int(
envs.get_global_env(
"runner." + context["runner_name"] + ".print_interval", 20))
scope = context["model"][model_name]["scope"]
program = context["model"][model_name]["main_program"]
reader = context["dataset"][reader_name]
with fluid.scope_guard(scope):
if context["is_infer"]:
metrics = model_class.get_infer_results()
if metrics:
fetch_vars = metrics.values()
fetch_alias = metrics.keys()
context["exe"].infer_from_dataset(program=program,
dataset=reader,
fetch_list=fetch_vars,
fetch_info=fetch_alias,
print_period=fetch_period,
debug=envs.get_global_env(
"debug", False))
else:
metrics = model_class.get_metrics()
if metrics:
fetch_vars = metrics.values()
fetch_alias = metrics.keys()
with fluid.scope_guard(scope):
context["exe"].train_from_dataset(
program=program,
dataset=reader,
fetch_list=fetch_vars,
fetch_info=fetch_alias,
print_period=fetch_period,
debug=envs.get_global_env("debug", False))
def transform_and_save_int8_model(original_path, save_path):
place = fluid.CPUPlace()
exe = fluid.Executor(place)
inference_scope = fluid.executor.global_scope()
with fluid.scope_guard(inference_scope):
if os.path.exists(os.path.join(original_path, '__model__')):
[inference_program, feed_target_names, fetch_targets
] = fluid.io.load_inference_model(original_path, exe)
else:
[inference_program, feed_target_names, fetch_targets
] = fluid.io.load_inference_model(original_path, exe, 'model',
'params')
ops_to_quantize = set()
if len(test_args.ops_to_quantize) > 0:
ops_to_quantize = set(test_args.ops_to_quantize.split(','))
op_ids_to_skip = set([-1])
if len(test_args.op_ids_to_skip) > 0:
op_ids_to_skip = set(map(int, test_args.op_ids_to_skip.split(',')))
graph = IrGraph(core.Graph(inference_program.desc), for_test=True)
if (test_args.debug):
graph.draw('.', 'quant_orig', graph.all_op_nodes())
transform_to_mkldnn_int8_pass = Quant2Int8MkldnnPass(
ops_to_quantize,
_op_ids_to_skip=op_ids_to_skip,
_scope=inference_scope,
_place=place,
_core=core,
_debug=test_args.debug)
graph = transform_to_mkldnn_int8_pass.apply(graph)
inference_program = graph.to_program()
with fluid.scope_guard(inference_scope):
fluid.io.save_inference_model(save_path, feed_target_names,
fetch_targets, exe,
inference_program)
print(
"Success! INT8 model obtained from the Quant model can be found at {}\n"
.format(save_path))
def _executor_dataloader_train(self, model_dict, context):
model_name = model_dict["name"]
model_class = context["model"][model_dict["name"]]["model"]
program = self._get_dataloader_program(model_dict, context)
fetch_period = int(
envs.get_global_env("runner." + context["runner_name"] +
".print_interval", 20))
if context["is_infer"]:
metrics = model_class.get_infer_results()
else:
metrics = model_class.get_metrics()
metrics_varnames = []
metrics_format = []
metrics_names = ["total_batch"]
metrics_format.append("{}: {{}}".format("batch"))
for name, var in metrics.items():
metrics_names.append(name)
metrics_varnames.append(var.name)
metrics_format.append("{}: {{}}".format(name))
metrics_format = ", ".join(metrics_format)
reader = context["model"][model_dict["name"]]["model"]._data_loader
reader.start()
batch_id = 0
scope = context["model"][model_name]["scope"]
result = None
with fluid.scope_guard(scope):
try:
while True:
metrics_tensors = context["exe"].run(
program=program,
fetch_list=metrics_varnames,
return_numpy=False)
metrics = [batch_id]
metrics_rets = [
as_numpy(metrics_tensor)
for metrics_tensor in metrics_tensors
]
metrics.extend(metrics_rets)
if batch_id % fetch_period == 0 and batch_id != 0:
print(metrics_format.format(*metrics))
batch_id += 1
except fluid.core.EOFException:
reader.reset()
if batch_id > 0:
result = dict(zip(metrics_names, metrics))
return result
def batch_predict(self, img_file_list, transforms=None):
"""预测。
Args:
img_file_list(list|tuple): 对列表（或元组）中的图像同时进行预测，列表中的元素可以是图像路径
也可以是解码后的排列格式为（H，W，C）且类型为float32且为BGR格式的数组。
transforms (paddlex.det.transforms): 数据预处理操作。
Returns:
dict: 每个元素都为列表，表示各图像的预测结果。在各图像的预测结果列表中，每个预测结果由预测框类别标签、预测框类别名称、
预测框坐标(坐标格式为[xmin, ymin, w, h]）、
原图大小的预测二值图（1表示预测框类别，0表示背景类）、
预测框得分组成。
"""
if transforms is None and not hasattr(self, 'test_transforms'):
raise Exception("transforms need to be defined, now is None.")
if not isinstance(img_file_list, (list, tuple)):
raise Exception("im_file must be list/tuple")
if transforms is None:
transforms = self.test_transforms
input_channel = getattr(self, 'input_channel', 3)
im, im_resize_info, im_shape = FasterRCNN._preprocess(
img_file_list,
transforms,
self.model_type,
self.__class__.__name__,
self.thread_pool,
input_channel=input_channel)
with fluid.scope_guard(self.scope):
result = self.exe.run(self.test_prog,
feed={
'image': im,
'im_info': im_resize_info,
'im_shape': im_shape
},
fetch_list=list(self.test_outputs.values()),
return_numpy=False,
use_program_cache=True)
res = {
k: (np.array(v), v.recursive_sequence_lengths())
for k, v in zip(list(self.test_outputs.keys()), result)
}
res['im_id'] = (np.array([[i] for i in range(len(img_file_list))
]).astype('int32'), [])
res['im_shape'] = (np.array(im_shape), [])
preds = MaskRCNN._postprocess(res, len(img_file_list),
self.num_classes,
self.mask_head_resolution, self.labels)
return preds
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):
#Get the inference program using fluid.io.load_inference_model,
#feed variable name by feed_target_names and fetch fetch_targets from scope
[inferencer, feed_target_names,
fetch_targets] = fluid.io.load_inference_model(params_dirname, exe)
# Set the input and use 4 LoDTensor to represent 4 words. Each word here is an id,
# Used to query the embedding table to get the corresponding word vector, so its shape size is [1].
# recursive_sequence_lengths sets the length based on LoD, so it should all be set to [[1]]
# Note that recursive_sequence_lengths is 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 the feed dictionary {feed_target_name: feed_target_data}
# Prediction results are included in results
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])
def _test(self, run_ipu=True):
scope = fluid.core.Scope()
main_prog = paddle.static.Program()
startup_prog = paddle.static.Program()
main_prog.random_seed = SEED
startup_prog.random_seed = SEED
np.random.seed(SEED)
np_image = np.random.rand(1, 3, 10, 10).astype(np.float32)
with fluid.scope_guard(scope):
with paddle.static.program_guard(main_prog, startup_prog):
image = paddle.static.data(name='image',
shape=[1, 3, 10, 10],
dtype='float32')
conv1 = paddle.static.nn.conv2d(image,
num_filters=3,
filter_size=3,
bias_attr=False)
loss = paddle.mean(conv1)
sgd = paddle.optimizer.SGD(learning_rate=LR_New())
sgd.minimize(loss)
if run_ipu:
place = paddle.IPUPlace()
else:
place = paddle.CPUPlace()
exe = paddle.static.Executor(place)
exe.run(startup_prog)
if run_ipu:
feed_list = [image.name]
fetch_list = [loss.name]
ipu_strategy = compiler.get_ipu_strategy()
ipu_strategy.is_training = True
program = compiler.IPUCompiledProgram(
main_prog,
ipu_strategy=ipu_strategy).compile(feed_list, fetch_list)
else:
program = main_prog
result = []
for epoch in range(100):
if hasattr(program, "lr_sheduler"):
program.lr_sheduler.step()
loss_res = exe.run(program,
feed={image.name: np_image},
fetch_list=[loss])
result.append(loss_res)
return np.array(result)
def test_prune_with_cache_program2(self):
'''
When use_prune=True, Executor should cache the pruned program.
If the only difference in fetch_list is optimize_ops during multiple runs,
the cache_keys should be different and get different pruned program.
'''
with _mock_guard(mock):
exe = fluid.Executor(fluid.CPUPlace())
exe.prune_called_times = 0
program = framework.Program()
startup_program = framework.Program()
scope = fluid.Scope()
with fluid.scope_guard(scope):
with fluid.program_guard(program, startup_program):
(x1, x2, y1, y2, label, loss1, loss2, w1_param_attrs,
w2_param_attrs) = self.net2()
adam_optimizer1 = fluid.optimizer.AdamOptimizer(
learning_rate=0.5)
train1 = adam_optimizer1.minimize(loss1)
adam_optimizer2 = fluid.optimizer.AdamOptimizer(
learning_rate=0.5)
train2 = adam_optimizer2.minimize(loss2)
exe.run(startup_program)
x_np = np.random.random(size=(10, 2)).astype('float32')
label_np = np.random.randint(1,
size=(10, 1)).astype('int64')
for i in range(10):
if i % 2:
res = exe.run(program,
feed={
'x1': x_np,
'x2': x_np,
'label': label_np
},
fetch_list=[loss1, loss2, train1],
use_prune=True)
else:
res = exe.run(program,
feed={
'x1': x_np,
'x2': x_np,
'label': label_np
},
fetch_list=[loss1, loss2, train2],
use_prune=True)
if i == 0:
self.assertEqual(exe.prune_called_times, 1)
elif i == 1:
self.assertEqual(exe.prune_called_times, 2)
else:
self.assertEqual(exe.prune_called_times, 2)
def convert(args):
ernie_export_path = f'{args.ernie_path}/ernie_persistables.pkl'
pretraining_params_path = f'{args.ernie_path}/paddle/params'
ernie_config_path = f'{args.ernie_path}/paddle/ernie_config.json'
ernie_vocab_path = f'{args.ernie_path}/paddle/vocab.txt'
unzip_message = f"Please unzip ERNIE paddle param archive into {args.ernie_path}/paddle"
if not os.path.exists(pretraining_params_path):
print(f"{pretraining_params_path} does not exist.", file=sys.stderr)
print(unzip_message, file=sys.stderr)
sys.exit(1)
if not os.path.exists(ernie_config_path):
print(f"{ernie_config_path} does not exist.", file=sys.stderr)
print(unzip_message, file=sys.stderr)
sys.exit(1)
if not os.path.exists(ernie_vocab_path):
print(f"{ernie_vocab_path} does not exist.", file=sys.stderr)
print(unzip_message, file=sys.stderr)
sys.exit(1)
ernie_config = ErnieConfig(ernie_config_path)
# Fix missing use_task_id
ernie_config._config_dict['use_task_id'] = True
ernie_config.print_config()
place = fluid.CPUPlace()
exe = fluid.Executor(place)
startup_prog = fluid.Program()
train_program = fluid.Program()
inference_scope = fluid.core.Scope()
with fluid.scope_guard(inference_scope):
with fluid.program_guard(train_program, startup_prog):
with fluid.unique_name.guard():
_ = create_model(args, ernie_config=ernie_config)
init_pretraining_params(
exe,
pretraining_params_path,
main_program=startup_prog,
use_fp16=args.use_fp16)
persistables = dict()
for var in filter(fluid.io.is_persistable, train_program.list_vars()):
numpy_value = fetch_var(var.name, inference_scope)
persistables[var.name] = numpy_value
if args.verbose:
print(var.name)
print("totally", len(persistables), "persistables")
with open(ernie_export_path, 'wb') as f:
pickle.dump(persistables, f)
return train_program
def quantize(self):
'''
Quantize the fp32 model. Use calibrate data to calculate the scale factor of
quantized variables, and inserts fake quant/dequant op to obtain the
quantized model.
Args:
None
Returns:
the program of quantized model.
'''
self._load_model_data()
self._collect_target_varnames()
self._set_activation_persistable()
batch_ct = 0
for data in self._data_loader():
batch_ct += 1
if self._batch_nums and batch_ct >= self._batch_nums:
break
batch_id = 0
logging.info("Start to run batch!")
for data in self._data_loader():
start = time.time()
with fluid.scope_guard(self._scope):
self._executor.run(program=self._program,
feed=data,
fetch_list=self._fetch_list,
return_numpy=False)
if self._algo == "KL":
self._sample_data(batch_id)
else:
self._sample_threshold()
end = time.time()
logging.debug(
'[Run batch data] Batch={}/{}, time_each_batch={} s.'.format(
str(batch_id + 1), str(batch_ct), str(end - start)))
batch_id += 1
if self._batch_nums and batch_id >= self._batch_nums:
break
logging.info("All run batch: ".format(batch_id))
self._reset_activation_persistable()
logging.info("Calculate scale factor ...")
if self._algo == "KL":
self._calculate_kl_threshold()
logging.info("Update the program ...")
if self._algo in ["KL", "abs_max"]:
self._update_program()
else:
self._save_input_threhold()
logging.info("Save ...")
self._save_output_threshold()
logging.info("Finish quant!")
return self._program
def _process_bow_feed(self, sentences):
seqs, seqs_lens = [], []
for sentence in sentences:
seq = [
self.vocabulary[token] for token in sentence
if token in self.vocabulary
]
seqs.append(seq)
seqs_lens.append(len(seq))
with fluid.scope_guard(self.infer_scope):
seqs_lod = fluid.create_lod_tensor(seqs, [seqs_lens], self.place)
return {'seq': seqs_lod}
def infer_once(args):
# check models file has already been finished
if os.path.exists(args.model_output_dir + "/_success"):
logger.info("using models from " + args.model_output_dir)
exe = fluid.Executor(fluid.CPUPlace())
Scope = fluid.Scope()
inference_prog()
with fluid.scope_guard(Scope):
fluid.io.load_persistables(
executor=exe, dirname=args.model_output_dir + "/")
inference_test(Scope, args.model_output_dir, args)
else:
logger.info("Wrong Directory or save model failed!")
def count_number(self, image_path):
with fluid.scope_guard(self.scope):
data = next(reader(image_path))
outputs = self.exe.run(self.infer_program,
feed=self.feeder.feed(data),
fetch_list=self.fetch_targets,
return_numpy=False)
bboxes = numpy.array(outputs[0])
scores = bboxes[:, 1].astype('float32')
num = 0
for x in scores:
if x >= self.score_thresh: num += 1
return num
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)
# Setup input by creating LoDTensor to represent sequence of words.
# Here each word is the basic element of the LoDTensor and the shape of
# each word (base_shape) should be [1] since it is simply an index to
# look up for the corresponding word vector.
# Suppose the length_based level of detail (lod) info is set to [[4, 6]],
# which has only one lod level. Then the created LoDTensor will have only
# one higher level structure (sequence of words, or sentence) than the basic
# element (word). Hence the LoDTensor will hold data for two sentences of
# length 4 and 6, respectively.
# Note that lod info should be a list of lists.
lod = [[4, 6]]
base_shape = [1]
# The range of random integers is [low, high]
word_data = fluid.create_random_int_lodtensor(
lod, base_shape, place, low=0, high=1)
trg_word = fluid.create_random_int_lodtensor(
lod, base_shape, place, low=0, high=1)
# Construct feed as a dictionary of {feed_target_name: feed_target_data}
# and results will contain a list of data corresponding to fetch_targets.
assert feed_target_names[0] == 'source_sequence'
assert feed_target_names[1] == 'target_sequence'
results = exe.run(inference_program,
feed={
feed_target_names[0]: word_data,
feed_target_names[1]: trg_word,
},
fetch_list=fetch_targets,
return_numpy=False)
print(results[0].lod())
np_data = np.array(results[0])
print("Inference shape: ", np_data.shape)
print("Inference results: ", np_data)
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)
# The input's dimension of conv should be 4-D or 5-D.
# Use normilized image pixels as input data, which should be in the range [0, 1.0].
batch_size = 1
tensor_img = numpy.random.rand(batch_size, 3, 32, 32).astype("float32")
# Use inference_transpiler to speedup
inference_transpiler_program = inference_program.clone()
t = fluid.InferenceTranspiler()
t.transpile(inference_transpiler_program, 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]: tensor_img},
fetch_list=fetch_targets)
transpiler_results = exe.run(inference_transpiler_program,
feed={feed_target_names[0]: tensor_img},
fetch_list=fetch_targets)
assert len(results[0]) == len(transpiler_results[0])
for i in range(len(results[0])):
np.testing.assert_almost_equal(
results[0][i], transpiler_results[0][i], decimal=5)
print("infer results: ", results[0])
fluid.io.save_inference_model(save_dirname, feed_target_names,
fetch_targets, exe,
inference_transpiler_program)
def main():
sys.path.append(os.getcwd())
some_test_failed = False
for module_name in sys.argv[1:]:
buffer = cStringIO.StringIO()
main = fluid.Program()
startup = fluid.Program()
scope = fluid.core.Scope()
with fluid.program_guard(main, startup):
with fluid.scope_guard(scope):
with fluid.unique_name.guard():
test_loader = unittest.TestLoader()
module = importlib.import_module(module_name)
tests = test_loader.loadTestsFromModule(module)
res = unittest.TextTestRunner(stream=buffer).run(tests)
if not res.wasSuccessful():
some_test_failed = True
print >> sys.stderr, module_name, 'failed\n', buffer.getvalue(
)
if some_test_failed:
exit(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]))
