m53297601
/
Paddle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rewrite inference_transpiler in Python end

Browse Source
wangkuiyi-patch-2
Luo Tao 8 years ago
parent 16e31343d8
commit ea0cf6f382
5 changed files with 41 additions and 104 deletions
Show Stats Download Patch File Download Diff File

50
paddle/fluid/framework/block_desc.cc
Unescape View File

@ -13,11 +13,10 @@ See the License for the specific language governing permissions and
limitations under the License. */
#include "paddle/fluid/framework/block_desc.h"
#include <queue>
#include "paddle/fluid/framework/operator.h"
#include "paddle/fluid/framework/program_desc.h"
#include <queue>
namespace paddle {
namespace framework {
@ -147,52 +146,7 @@ void BlockDesc::RemoveOp(size_t s, size_t e) {
if (ops_.begin() + s == ops_.end() || ops_.begin() + e == ops_.end()) {
return;
}
auto get_vars = [](std::deque<std::unique_ptr<OpDesc>>::iterator &op,
std::vector<std::string> &v) {
auto in_names = (*op)->InputArgumentNames();
v.insert(v.end(), in_names.begin(), in_names.end());
auto out_names = (*op)->OutputArgumentNames();
v.insert(v.end(), out_names.begin(), out_names.end());
std::sort(v.begin(), v.end());
auto last = std::unique(v.begin(), v.end());
v.erase(last, v.end());
};
need_update_ = true;
for (size_t i = s; i < e; i++) {
// since remove op one by one, every time remove the first op.
auto op = ops_.begin() + s;
// collect input and output variables from current delete op
std::vector<std::string> cur_vars;
get_vars(op, cur_vars);
// remove current op
ops_.erase(ops_.begin() + s);
// collect input and output variables from other ops
std::vector<std::string> other_vars;
for (auto it = ops_.begin(); it != ops_.end(); it++) {
get_vars(it, other_vars);
}
// variables should be deleted
std::vector<std::string> delete_vars;
// delete_vars = cur_vars - cur_vars ^ other_input_vars
std::set_difference(cur_vars.begin(), cur_vars.end(), other_vars.begin(),
other_vars.end(),
std::inserter(delete_vars, delete_vars.end()));
// remove variables
for (size_t i = 0; i < delete_vars.size(); i++) {
auto name = delete_vars[i];
auto it = vars_.find(name);
PADDLE_ENFORCE(it != vars_.end(),
"%s is not in variable list, it should not be deleted",
name);
vars_.erase(it);
VLOG(3) << "deleting variable " << name;
}
}
ops_.erase(ops_.begin() + s, ops_.begin() + e);
}
std::vector<OpDesc *> BlockDesc::AllOps() const {

20
python/paddle/fluid/framework.py
Unescape View File

@ -818,6 +818,11 @@ class Block(object):
del self.vars[name]
self.sync_with_cpp()
def remove_var(self, name):
self.sync_with_cpp()
self.desc.remove_var(name)
del self.vars[name]
def create_parameter(self, *args, **kwargs):
global_block = self.program.global_block()
param = Parameter(global_block, *args, **kwargs)
@ -838,6 +843,11 @@ class Block(object):
self.ops.insert(index, op)
return op
def remove_op(self, index):
self.sync_with_cpp()
self.desc.remove_op(index, index + 1)
del self.ops[index]
def delete_ops(self, ops):
# remove from cpp
# FIXME(typhoonzero): remove only the first occurrence.
@ -846,6 +856,7 @@ class Block(object):
end = list(self.ops).index(ops[-1])
except Exception, e:
raise e
self.desc.remove_op(start, end + 1)
def slice_ops(self, start, end):
@ -920,15 +931,6 @@ class Block(object):
ops_in_cpp_index += 1
ops_in_python_index += 1
# sync ops inserted from c++ end
if len(self.ops) != len(ops_in_cpp) and start_index == 0 and len(
self.ops) == end_index:
del self.ops[:]
for index in range(len(ops_in_cpp)):
op_desc = ops_in_cpp[index]
op = Operator(self, op_desc)
self.ops.append(op)
assert len(self.ops) == len(ops_in_cpp)
for index in range(len(self.ops)):
assert self.ops[index].desc == ops_in_cpp[index]

51
python/paddle/fluid/inference_transpiler.py
Unescape View File

@ -61,30 +61,26 @@ class InferenceTranspiler:
'''
self.scope = scope
self.place = place
self.block_desc = program.get_desc().block(0)
self.block = program.block(0)
i = 0
while i < self.block_desc.op_size():
current_op = self.block_desc.op(i)
while i < len(self.block.ops):
current_op = self.block.ops[i]
# TODO(luotao1): consider only conv2d now. fc would be delt later.
if current_op.type() in ['conv2d']:
next_op = self.block_desc.op(i + 1)
if current_op.type in ['conv2d']:
next_op = self.block.ops[i + 1]
# TODO(luotao1): consider only conv2d without bias now.
# If conv2d with bias, the next_op.type is elementwise_add.
if (next_op.type() == 'batch_norm'):
if (next_op.type == 'batch_norm'):
# insert bias op
bias_op = self._insert_bias_op(i + 1, current_op, next_op)
program.sync_with_cpp()
# fuse batch_norm
self._fuse_param(current_op, next_op, bias_op)
# remove batch_norm_op
self.block_desc.remove_op(i + 2, i + 3)
program.sync_with_cpp()
self.block.remove_op(i + 2)
i = i + 1
i = i + 1
self._remove_unused_var()
program.sync_with_cpp()
return program
# ====================== private transpiler functions =====================
@ -102,14 +98,19 @@ class InferenceTranspiler:
:return: bias_op
:rtype: Operator
'''
bias_op = self.block_desc.insert_op(index)
bias_op.set_type("elementwise_add")
# The input of bias_op is current_op's output and Bias of bn_op
# The output of bias_op is bn_op's output
bias_op.set_input("X", current_op.output("Output"))
bias_op.set_input("Y", bn_op.input("Bias"))
bias_op.set_output("Out", bn_op.output("Y"))
bias_op.set_attr('axis', 1) # dim_start=1
x_var = self.block.var(current_op.output("Output")[0])
y_var = self.block.var(bn_op.input("Bias")[0])
out_var = self.block.var(bn_op.output("Y")[0])
bias_op = self.block.insert_op(
index,
type="elementwise_add",
inputs={"X": x_var,
"Y": y_var},
outputs={"Out": out_var},
attrs={"axis": 1}) # dim_start=1
return bias_op
def _fuse_param(self, current_op, bn_op, bias_op):
@ -160,15 +161,15 @@ class InferenceTranspiler:
def _remove_unused_var(self):
'''
remove unused varibles in program desc
remove unused varibles in program
'''
args = []
for i in xrange(0, self.block_desc.op_size()):
current_op = self.block_desc.op(i)
args += current_op.input_arg_names()
args += current_op.output_arg_names()
for i in range(len(self.block.ops)):
current_op = self.block.ops[i]
args += current_op.input_arg_names
args += current_op.output_arg_names
args = list(set(args)) # unique the input and output arguments
for var in self.block_desc.all_vars():
if var.name() not in args:
self.block_desc.remove_var(var.name())
for var in self.block.vars.keys():
if var not in args:
self.block.remove_var(var)

4
python/paddle/fluid/tests/book/test_image_classification.py
Unescape View File

@ -236,8 +236,8 @@ def infer(use_cuda, save_dirname=None):
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])
np.testing.assert_almost_equal(
results[0][i], transpiler_results[0][i], decimal=6)
print("infer results: ", results[0])

20
python/paddle/fluid/tests/unittests/test_protobuf_descs.py
Unescape View File

@ -201,24 +201,6 @@ class TestBlockDesc(unittest.TestCase):
op1.set_type("test")
op2.set_type("test")
var0 = block.var("var0")
var1 = block.var("var1")
var2 = block.var("var2")
var3 = block.var("var3")
var4 = block.var("var4")
var5 = block.var("var5")
op0.set_input("X", ["var0"])
op0.set_output("Y", ["var0"])
op1.set_input("X", ["var1", "var2"])
op1.set_output("Y", ["var3", "var4"])
op2.set_input("X", ["var1"])
op2.set_output("Y", ["var4", "var5"])
program.sync_with_cpp()
# remove op1, its input var2 and output var3 will be removed at the same time,
# but its input var1 and output var4 will not be removed since they are used for op2.
block.remove_op(1, 2)
program.sync_with_cpp()
@ -226,8 +208,6 @@ class TestBlockDesc(unittest.TestCase):
for idx in xrange(0, block.op_size()):
all_ops.append(block.op(idx))
self.assertEqual(all_ops, [op0, op2])
all_vars = block.all_vars()
self.assertEqual(set(all_vars), {var0, var1, var4, var5})
if __name__ == '__main__':

Write Preview
Loading…
Cancel
Save