Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
机器未来
Paddle
提交
c3b46d16
P
Paddle
项目概览
机器未来
/
Paddle
与 Fork 源项目一致
Fork自
PaddlePaddle / Paddle
通知
1
Star
1
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
1
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
P
Paddle
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
1
Issue
1
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
c3b46d16
编写于
10月 06, 2017
作者:
F
fengjiayi
提交者:
GitHub
10月 06, 2017
浏览文件
操作
浏览文件
下载
差异文件
Merge pull request #4573 from Canpio/dev_backward_for_op_desc
Backward for op desc
上级
cb1baa3b
bd7b6692
变更
8
隐藏空白更改
内联
并排
Showing
8 changed file
with
520 addition
and
1 deletion
+520
-1
paddle/framework/backward.cc
paddle/framework/backward.cc
+142
-0
paddle/framework/backward.h
paddle/framework/backward.h
+8
-1
paddle/framework/backward_test.cc
paddle/framework/backward_test.cc
+305
-0
paddle/framework/block_desc.h
paddle/framework/block_desc.h
+8
-0
paddle/framework/op_desc.cc
paddle/framework/op_desc.cc
+37
-0
paddle/framework/op_desc.h
paddle/framework/op_desc.h
+11
-0
paddle/framework/op_registry.cc
paddle/framework/op_registry.cc
+6
-0
paddle/framework/op_registry.h
paddle/framework/op_registry.h
+3
-0
未找到文件。
paddle/framework/backward.cc
浏览文件 @
c3b46d16
...
...
@@ -15,9 +15,11 @@
#include "paddle/framework/backward.h"
#include "paddle/operators/net_op.h"
#include <deque>
#include <list>
#include <memory>
#include "paddle/framework/block_desc.h"
#include "paddle/framework/op_registry.h"
#include "paddle/operators/net_op.h"
#include "paddle/operators/recurrent_op.h"
...
...
@@ -270,5 +272,145 @@ std::unique_ptr<OperatorBase> Backward(
return
BackwardRecursive
(
forwardOp
,
no_grad_names
,
uid
);
}
// ==================================== //
static
bool
AllGradInSet
(
const
std
::
vector
<
std
::
string
>&
names
,
const
std
::
unordered_set
<
std
::
string
>&
set
)
{
for
(
const
std
::
string
&
name
:
names
)
{
if
(
!
set
.
count
(
GradVarName
(
name
)))
{
return
false
;
}
}
return
true
;
}
std
::
vector
<
std
::
unique_ptr
<
OpDescBind
>>
MakeOpGrad
(
const
std
::
unique_ptr
<
OpDescBind
>&
op_desc
,
std
::
unordered_set
<
std
::
string
>&
no_grad_vars
)
{
std
::
vector
<
std
::
unique_ptr
<
OpDescBind
>>
grad_op_descs
;
// All input gradients of forwarding operator do not need to calculat.
const
std
::
vector
<
std
::
string
>&
inputs
=
op_desc
->
InputArgumentNames
();
if
(
AllGradInSet
(
inputs
,
no_grad_vars
))
{
return
grad_op_descs
;
// empty vector
}
// All output gradients of forwarding operator do not need to calculate.
const
std
::
vector
<
std
::
string
>&
outputs
=
op_desc
->
OutputArgumentNames
();
if
(
AllGradInSet
(
outputs
,
no_grad_vars
))
{
for
(
const
std
::
string
&
name
:
inputs
)
{
no_grad_vars
.
insert
(
GradVarName
(
name
));
}
return
grad_op_descs
;
// empty vector
}
grad_op_descs
=
OpRegistry
::
CreateGradOpDescs
(
*
op_desc
);
std
::
list
<
std
::
unique_ptr
<
OpDescBind
>>
pending_fill_zeros_ops
;
for
(
auto
&
desc
:
grad_op_descs
)
{
for
(
const
std
::
string
&
in_name
:
desc
->
InputArgumentNames
())
{
if
(
no_grad_vars
.
count
(
in_name
))
{
std
::
string
prefix
=
in_name
.
substr
(
0
,
in_name
.
size
()
-
sizeof
(
kGradVarSuffix
)
/
sizeof
(
char
)
+
1
);
std
::
string
new_name
=
prefix
+
kZeroVarSuffix
;
desc
->
Rename
(
in_name
,
new_name
);
std
::
unique_ptr
<
OpDescBind
>
fill_zeros_op
(
new
OpDescBind
(
"fill_zeros_like"
,
{{
"X"
,
{
prefix
}}},
{{
"Y"
,
{
new_name
}}},
{}));
pending_fill_zeros_ops
.
push_back
(
std
::
move
(
fill_zeros_op
));
}
}
for
(
const
std
::
string
&
out_name
:
desc
->
OutputArgumentNames
())
{
if
(
no_grad_vars
.
count
(
out_name
))
{
desc
->
Rename
(
out_name
,
kEmptyVarName
);
}
}
}
for
(
auto
&
p
:
pending_fill_zeros_ops
)
{
grad_op_descs
.
insert
(
grad_op_descs
.
begin
(),
std
::
move
(
p
));
}
return
grad_op_descs
;
}
std
::
vector
<
std
::
unique_ptr
<
OpDescBind
>>
MakeBlockBackward
(
ProgramDescBind
&
program_desc
,
int
block_idx
,
std
::
unordered_set
<
std
::
string
>&
no_grad_vars
)
{
BlockDescBind
*
cur_block
=
program_desc
.
Block
(
block_idx
);
std
::
deque
<
std
::
unique_ptr
<
OpDescBind
>>&
op_descs
=
cur_block
->
ops_
;
std
::
unordered_map
<
std
::
string
,
std
::
vector
<
size_t
>>
dup_out_ops
;
size_t
grad_desc_idx
=
0
;
std
::
vector
<
std
::
unique_ptr
<
OpDescBind
>>
backward_descs
;
for
(
auto
it
=
op_descs
.
rbegin
();
it
!=
op_descs
.
rend
();
++
it
)
{
std
::
vector
<
std
::
unique_ptr
<
OpDescBind
>>
op_grads
=
MakeOpGrad
(
*
it
,
no_grad_vars
);
if
((
*
it
)
->
Type
()
==
"recurrent"
)
{
PADDLE_ENFORCE_EQ
(
op_grads
.
size
(),
size_t
(
1
),
"rnn_op's gradient process should contain only one op."
);
int
step_block_idx
=
(
*
it
)
->
GetBlockAttr
(
"stop_block"
);
auto
backward_block_op_descs
=
MakeBlockBackward
(
program_desc
,
step_block_idx
,
no_grad_vars
);
BlockDescBind
*
backward_block
=
program_desc
.
AppendBlock
(
*
cur_block
);
for
(
auto
&
ptr
:
backward_block_op_descs
)
{
backward_block
->
ops_
.
push_back
(
std
::
move
(
ptr
));
}
op_grads
[
0
]
->
SetBlockAttr
(
"step_block"
,
*
backward_block
);
}
for
(
const
auto
&
desc
:
op_grads
)
{
for
(
const
std
::
string
&
out_name
:
desc
->
OutputArgumentNames
())
{
dup_out_ops
[
out_name
].
emplace_back
(
grad_desc_idx
);
}
++
grad_desc_idx
;
}
std
::
transform
(
op_grads
.
begin
(),
op_grads
.
end
(),
std
::
back_inserter
(
backward_descs
),
[](
std
::
unique_ptr
<
OpDescBind
>&
ptr
)
{
return
std
::
move
(
ptr
);
});
}
// Check whether some variables are written more than once
std
::
list
<
std
::
pair
<
size_t
,
std
::
unique_ptr
<
OpDescBind
>>>
pending_sum_ops
;
for
(
const
auto
&
dup
:
dup_out_ops
)
{
const
std
::
string
&
out_name
=
dup
.
first
;
const
std
::
vector
<
size_t
>
dup_op
=
dup
.
second
;
if
(
out_name
!=
kEmptyVarName
&&
dup_op
.
size
()
>
1
)
{
std
::
vector
<
std
::
string
>
sum_op_inputs
;
for
(
size_t
i
=
0
;
i
<
dup_op
.
size
();
++
i
)
{
std
::
string
new_name
=
out_name
+
"@RENAME@"
+
std
::
to_string
(
i
);
backward_descs
[
dup_op
[
i
]]
->
Rename
(
out_name
,
new_name
);
sum_op_inputs
.
emplace_back
(
new_name
);
}
std
::
unique_ptr
<
OpDescBind
>
sum_op
(
new
OpDescBind
(
"sum"
,
{{
"X"
,
sum_op_inputs
}},
{{
"Out"
,
{
out_name
}}},
{}));
pending_sum_ops
.
push_back
({
dup_op
.
back
(),
std
::
move
(
sum_op
)});
}
}
pending_sum_ops
.
sort
(
[](
const
std
::
pair
<
size_t
,
std
::
unique_ptr
<
OpDescBind
>>&
a
,
const
std
::
pair
<
size_t
,
std
::
unique_ptr
<
OpDescBind
>>&
b
)
{
return
a
.
first
>
b
.
first
;
});
for
(
auto
&
p
:
pending_sum_ops
)
{
backward_descs
.
insert
(
backward_descs
.
begin
()
+
p
.
first
+
1
,
std
::
move
(
p
.
second
));
}
return
backward_descs
;
}
void
AppendBackward
(
ProgramDescBind
&
program_desc
,
const
std
::
unordered_set
<
std
::
string
>&
no_grad_vars
)
{
std
::
unordered_set
<
std
::
string
>
no_grad_var_names
;
no_grad_var_names
.
reserve
(
no_grad_vars
.
size
()
+
1
);
no_grad_var_names
.
insert
(
std
::
string
(
kEmptyVarName
)
+
kGradVarSuffix
);
for
(
auto
&
name
:
no_grad_vars
)
{
no_grad_var_names
.
insert
(
GradVarName
(
name
));
}
const
int
root_block_idx
=
0
;
auto
backward_op_descs
=
MakeBlockBackward
(
program_desc
,
root_block_idx
,
no_grad_var_names
);
auto
&
forw_op_descs
=
program_desc
.
Block
(
root_block_idx
)
->
ops_
;
for
(
auto
&
ptr
:
backward_op_descs
)
{
forw_op_descs
.
push_back
(
std
::
move
(
ptr
));
}
}
}
// namespace framework
}
// namespace paddle
paddle/framework/backward.h
浏览文件 @
c3b46d16
...
...
@@ -13,8 +13,11 @@
limitations under the License. */
#pragma once
#include <unordered_set>
#include "operator.h"
#include "paddle/framework/operator.h"
#include "paddle/framework/program_desc.h"
namespace
paddle
{
namespace
framework
{
...
...
@@ -23,5 +26,9 @@ namespace framework {
extern
std
::
unique_ptr
<
OperatorBase
>
Backward
(
const
OperatorBase
&
forwardOp
,
const
std
::
unordered_set
<
std
::
string
>&
no_grad_vars
);
void
AppendBackward
(
ProgramDescBind
&
program_desc
,
const
std
::
unordered_set
<
std
::
string
>&
no_grad_vars
);
}
// namespace framework
}
// namespace paddle
paddle/framework/backward_test.cc
浏览文件 @
c3b46d16
...
...
@@ -15,6 +15,8 @@
#include "paddle/framework/backward.h"
#include <gtest/gtest.h>
#include "paddle/framework/block_desc.h"
#include "paddle/framework/op_desc.h"
#include "paddle/framework/op_registry.h"
#include "paddle/operators/net_op.h"
...
...
@@ -153,6 +155,18 @@ class SumOpMaker : public framework::OpProtoAndCheckerMaker {
}
};
class
MultInOutOpMaker
:
public
OpProtoAndCheckerMaker
{
public:
MultInOutOpMaker
(
OpProto
*
proto
,
OpAttrChecker
*
op_checker
)
:
OpProtoAndCheckerMaker
(
proto
,
op_checker
)
{
AddInput
(
"X"
,
"x"
);
AddInput
(
"H"
,
"h"
);
AddOutput
(
"Y"
,
"y"
);
AddOutput
(
"Z"
,
"z"
);
AddComment
(
""
);
}
};
}
// namespace framework
}
// namespace paddle
...
...
@@ -170,6 +184,7 @@ REGISTER_OP(sum, f::NOP, f::SumOpMaker, sum_grad, f::NOP);
REGISTER_OP_WITHOUT_GRADIENT
(
fc
,
f
::
FcOp
,
f
::
FcOpMaker
);
REGISTER_OP
(
many_output_op
,
f
::
NOP
,
f
::
ManyOutputOpMaker
,
many_output_op_grad
,
f
::
NOP
);
REGISTER_OP
(
mult_in_out
,
f
::
NOP
,
f
::
MultInOutOpMaker
,
mult_in_out_grad
,
f
::
NOP
);
TEST
(
Backward
,
simple_op_not_need_grad
)
{
auto
fwd
=
f
::
OpRegistry
::
CreateOp
(
...
...
@@ -389,3 +404,293 @@ TEST(Backward, linear_net_intermediate_variable_has_no_grad) {
EXPECT_EQ
(
bwd_net
->
ops_
[
2
]
->
Inputs
(
all
).
size
(),
0UL
);
EXPECT_EQ
(
bwd_net
->
ops_
[
2
]
->
Outputs
(
all
).
size
(),
0UL
);
}
// =================================== //
f
::
ProgramDesc
*
GetNewProgramDesc
()
{
auto
*
program_desc
=
new
f
::
ProgramDesc
();
auto
*
root_block
=
program_desc
->
add_blocks
();
root_block
->
set_idx
(
0
);
root_block
->
set_parent_idx
(
-
1
);
return
program_desc
;
}
TEST
(
Backward
,
simple_single_op
)
{
f
::
ProgramDesc
*
program_desc
=
GetNewProgramDesc
();
f
::
ProgramDescBind
&
program
=
f
::
ProgramDescBind
::
Instance
(
program_desc
);
f
::
BlockDescBind
*
block
=
program
.
Block
(
0
);
f
::
OpDescBind
*
op
=
block
->
AppendOp
();
op
->
SetType
(
"rowwise_add"
);
op
->
SetInput
(
"X"
,
{
"x"
});
op
->
SetInput
(
"b"
,
{
"b"
});
op
->
SetOutput
(
"Out"
,
{
"out"
});
AppendBackward
(
program
,
{});
ASSERT_EQ
(
block
->
AllOps
().
size
(),
2UL
);
f
::
OpDescBind
*
grad_op
=
block
->
AllOps
()[
1
];
EXPECT_EQ
(
grad_op
->
Type
(),
"rowwise_add_grad"
);
ASSERT_EQ
(
grad_op
->
InputNames
().
size
(),
1UL
);
ASSERT_EQ
(
grad_op
->
OutputNames
().
size
(),
2UL
);
EXPECT_EQ
(
grad_op
->
Input
(
f
::
GradVarName
(
"Out"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out"
)}));
EXPECT_EQ
(
grad_op
->
Output
(
f
::
GradVarName
(
"X"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"x"
)}));
EXPECT_EQ
(
grad_op
->
Output
(
f
::
GradVarName
(
"b"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"b"
)}));
}
TEST
(
Backward
,
simple_mult_op
)
{
f
::
ProgramDesc
*
program_desc
=
GetNewProgramDesc
();
f
::
ProgramDescBind
&
program
=
f
::
ProgramDescBind
::
Instance
(
program_desc
);
f
::
BlockDescBind
*
block
=
program
.
Block
(
0
);
f
::
OpDescBind
*
op1
=
block
->
AppendOp
();
op1
->
SetType
(
"rowwise_add"
);
op1
->
SetInput
(
"X"
,
{
"x1"
});
op1
->
SetInput
(
"b"
,
{
"b1"
});
op1
->
SetOutput
(
"Out"
,
{
"out1"
});
f
::
OpDescBind
*
op2
=
block
->
AppendOp
();
op2
->
SetType
(
"mul"
);
op2
->
SetInput
(
"X"
,
{
"out1"
});
op2
->
SetInput
(
"Y"
,
{
"y2"
});
op2
->
SetOutput
(
"Out"
,
{
"out2"
});
f
::
OpDescBind
*
op3
=
block
->
AppendOp
();
op3
->
SetType
(
"rowwise_add"
);
op3
->
SetInput
(
"X"
,
{
"out2"
});
op3
->
SetInput
(
"b"
,
{
"b3"
});
op3
->
SetOutput
(
"Out"
,
{
"out3"
});
AppendBackward
(
program
,
{});
ASSERT_EQ
(
block
->
AllOps
().
size
(),
6UL
);
f
::
OpDescBind
*
grad_op1
=
block
->
AllOps
()[
5
];
EXPECT_EQ
(
grad_op1
->
Type
(),
"rowwise_add_grad"
);
ASSERT_EQ
(
grad_op1
->
InputNames
().
size
(),
1UL
);
ASSERT_EQ
(
grad_op1
->
OutputNames
().
size
(),
2UL
);
EXPECT_EQ
(
grad_op1
->
Input
(
f
::
GradVarName
(
"Out"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out1"
)}));
EXPECT_EQ
(
grad_op1
->
Output
(
f
::
GradVarName
(
"X"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"x1"
)}));
EXPECT_EQ
(
grad_op1
->
Output
(
f
::
GradVarName
(
"b"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"b1"
)}));
f
::
OpDescBind
*
grad_op2
=
block
->
AllOps
()[
4
];
EXPECT_EQ
(
grad_op2
->
Type
(),
"mul_grad"
);
ASSERT_EQ
(
grad_op2
->
InputNames
().
size
(),
4UL
);
ASSERT_EQ
(
grad_op2
->
OutputNames
().
size
(),
2UL
);
EXPECT_EQ
(
grad_op2
->
Input
(
"X"
),
std
::
vector
<
std
::
string
>
({
"out1"
}));
EXPECT_EQ
(
grad_op2
->
Input
(
"Y"
),
std
::
vector
<
std
::
string
>
({
"y2"
}));
EXPECT_EQ
(
grad_op2
->
Input
(
"Out"
),
std
::
vector
<
std
::
string
>
({
"out2"
}));
EXPECT_EQ
(
grad_op2
->
Input
(
f
::
GradVarName
(
"Out"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out2"
)}));
EXPECT_EQ
(
grad_op2
->
Output
(
f
::
GradVarName
(
"X"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out1"
)}));
EXPECT_EQ
(
grad_op2
->
Output
(
f
::
GradVarName
(
"Y"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"y2"
)}));
f
::
OpDescBind
*
grad_op3
=
block
->
AllOps
()[
3
];
EXPECT_EQ
(
grad_op3
->
Type
(),
"rowwise_add_grad"
);
ASSERT_EQ
(
grad_op3
->
InputNames
().
size
(),
1UL
);
ASSERT_EQ
(
grad_op3
->
OutputNames
().
size
(),
2UL
);
EXPECT_EQ
(
grad_op3
->
Input
(
f
::
GradVarName
(
"Out"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out3"
)}));
EXPECT_EQ
(
grad_op3
->
Output
(
f
::
GradVarName
(
"X"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out2"
)}));
EXPECT_EQ
(
grad_op3
->
Output
(
f
::
GradVarName
(
"b"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"b3"
)}));
}
TEST
(
Backward
,
intermedia_var_no_grad
)
{
f
::
ProgramDesc
*
program_desc
=
GetNewProgramDesc
();
f
::
ProgramDescBind
&
program
=
f
::
ProgramDescBind
::
Instance
(
program_desc
);
f
::
BlockDescBind
*
block
=
program
.
Block
(
0
);
f
::
OpDescBind
*
op1
=
block
->
AppendOp
();
op1
->
SetType
(
"rowwise_add"
);
op1
->
SetInput
(
"X"
,
{
"x1"
});
op1
->
SetInput
(
"b"
,
{
"b1"
});
op1
->
SetOutput
(
"Out"
,
{
"out1"
});
f
::
OpDescBind
*
op2
=
block
->
AppendOp
();
op2
->
SetType
(
"mul"
);
op2
->
SetInput
(
"X"
,
{
"x2"
});
op2
->
SetInput
(
"Y"
,
{
"y2"
});
op2
->
SetOutput
(
"Out"
,
{
"out2"
});
f
::
OpDescBind
*
op3
=
block
->
AppendOp
();
op3
->
SetType
(
"rowwise_add"
);
op3
->
SetInput
(
"X"
,
{
"out2"
});
op3
->
SetInput
(
"b"
,
{
"b3"
});
op3
->
SetOutput
(
"Out"
,
{
"out3"
});
f
::
OpDescBind
*
op4
=
block
->
AppendOp
();
op4
->
SetType
(
"mul"
);
op4
->
SetInput
(
"X"
,
{
"out1"
});
op4
->
SetInput
(
"Y"
,
{
"out3"
});
op4
->
SetOutput
(
"Out"
,
{
"out4"
});
AppendBackward
(
program
,
{
"out3"
});
ASSERT_EQ
(
block
->
AllOps
().
size
(),
6UL
);
f
::
OpDescBind
*
grad_op1
=
block
->
AllOps
()[
5
];
EXPECT_EQ
(
grad_op1
->
Type
(),
"rowwise_add_grad"
);
ASSERT_EQ
(
grad_op1
->
InputNames
().
size
(),
1UL
);
ASSERT_EQ
(
grad_op1
->
OutputNames
().
size
(),
2UL
);
EXPECT_EQ
(
grad_op1
->
Input
(
f
::
GradVarName
(
"Out"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out1"
)}));
EXPECT_EQ
(
grad_op1
->
Output
(
f
::
GradVarName
(
"X"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"x1"
)}));
EXPECT_EQ
(
grad_op1
->
Output
(
f
::
GradVarName
(
"b"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"b1"
)}));
f
::
OpDescBind
*
grad_op4
=
block
->
AllOps
()[
4
];
EXPECT_EQ
(
grad_op4
->
Type
(),
"mul_grad"
);
ASSERT_EQ
(
grad_op4
->
InputNames
().
size
(),
4UL
);
ASSERT_EQ
(
grad_op4
->
OutputNames
().
size
(),
2UL
);
EXPECT_EQ
(
grad_op4
->
Input
(
"X"
),
std
::
vector
<
std
::
string
>
({
"out1"
}));
EXPECT_EQ
(
grad_op4
->
Input
(
"Y"
),
std
::
vector
<
std
::
string
>
({
"out3"
}));
EXPECT_EQ
(
grad_op4
->
Input
(
"Out"
),
std
::
vector
<
std
::
string
>
({
"out4"
}));
EXPECT_EQ
(
grad_op4
->
Input
(
f
::
GradVarName
(
"Out"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out4"
)}));
EXPECT_EQ
(
grad_op4
->
Output
(
f
::
GradVarName
(
"X"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out1"
)}));
EXPECT_EQ
(
grad_op4
->
Output
(
f
::
GradVarName
(
"Y"
)),
std
::
vector
<
std
::
string
>
({
f
::
kEmptyVarName
}));
}
TEST
(
Backward
,
var_no_grad
)
{
f
::
ProgramDesc
*
program_desc
=
GetNewProgramDesc
();
f
::
ProgramDescBind
&
program
=
f
::
ProgramDescBind
::
Instance
(
program_desc
);
f
::
BlockDescBind
*
block
=
program
.
Block
(
0
);
f
::
OpDescBind
*
op1
=
block
->
AppendOp
();
op1
->
SetType
(
"mult_in_out"
);
op1
->
SetInput
(
"X"
,
{
"x1"
});
op1
->
SetInput
(
"H"
,
{
"h1"
});
op1
->
SetOutput
(
"Y"
,
{
"y1"
});
op1
->
SetOutput
(
"Z"
,
{
"z1"
});
f
::
OpDescBind
*
op2
=
block
->
AppendOp
();
op2
->
SetType
(
"mult_in_out"
);
op2
->
SetInput
(
"X"
,
{
"y1"
});
op2
->
SetInput
(
"H"
,
{
"z1"
});
op2
->
SetOutput
(
"Y"
,
{
"y2"
});
op2
->
SetOutput
(
"Z"
,
{
"z2"
});
AppendBackward
(
program
,
{
"z1"
});
ASSERT_EQ
(
block
->
AllOps
().
size
(),
5UL
);
f
::
OpDescBind
*
grad_op2
=
block
->
AllOps
()[
2
];
ASSERT_EQ
(
grad_op2
->
Type
(),
"mult_in_out_grad"
);
ASSERT_EQ
(
grad_op2
->
InputNames
().
size
(),
6UL
);
ASSERT_EQ
(
grad_op2
->
OutputNames
().
size
(),
2UL
);
EXPECT_EQ
(
grad_op2
->
Input
(
"X"
),
std
::
vector
<
std
::
string
>
({
"y1"
}));
EXPECT_EQ
(
grad_op2
->
Input
(
"H"
),
std
::
vector
<
std
::
string
>
({
"z1"
}));
EXPECT_EQ
(
grad_op2
->
Input
(
"Y"
),
std
::
vector
<
std
::
string
>
({
"y2"
}));
EXPECT_EQ
(
grad_op2
->
Input
(
"Z"
),
std
::
vector
<
std
::
string
>
({
"z2"
}));
EXPECT_EQ
(
grad_op2
->
Input
(
f
::
GradVarName
(
"Y"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"y2"
)}));
EXPECT_EQ
(
grad_op2
->
Input
(
f
::
GradVarName
(
"Z"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"z2"
)}));
EXPECT_EQ
(
grad_op2
->
Output
(
f
::
GradVarName
(
"X"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"y1"
)}));
EXPECT_EQ
(
grad_op2
->
Output
(
f
::
GradVarName
(
"H"
)),
std
::
vector
<
std
::
string
>
({
f
::
kEmptyVarName
}));
f
::
OpDescBind
*
fill_zero_op
=
block
->
AllOps
()[
3
];
ASSERT_EQ
(
fill_zero_op
->
Type
(),
"fill_zeros_like"
);
ASSERT_EQ
(
fill_zero_op
->
InputNames
().
size
(),
1UL
);
ASSERT_EQ
(
fill_zero_op
->
OutputNames
().
size
(),
1UL
);
EXPECT_EQ
(
fill_zero_op
->
Input
(
"X"
),
std
::
vector
<
std
::
string
>
({
"z1"
}));
EXPECT_EQ
(
fill_zero_op
->
Output
(
"Y"
),
std
::
vector
<
std
::
string
>
({
std
::
string
(
"z1"
)
+
f
::
kZeroVarSuffix
}));
f
::
OpDescBind
*
grad_op1
=
block
->
AllOps
()[
4
];
ASSERT_EQ
(
grad_op1
->
Type
(),
"mult_in_out_grad"
);
ASSERT_EQ
(
grad_op1
->
InputNames
().
size
(),
6UL
);
ASSERT_EQ
(
grad_op1
->
OutputNames
().
size
(),
2UL
);
EXPECT_EQ
(
grad_op1
->
Input
(
"X"
),
std
::
vector
<
std
::
string
>
({
"x1"
}));
EXPECT_EQ
(
grad_op1
->
Input
(
"H"
),
std
::
vector
<
std
::
string
>
({
"h1"
}));
EXPECT_EQ
(
grad_op1
->
Input
(
"Y"
),
std
::
vector
<
std
::
string
>
({
"y1"
}));
EXPECT_EQ
(
grad_op1
->
Input
(
"Z"
),
std
::
vector
<
std
::
string
>
({
"z1"
}));
EXPECT_EQ
(
grad_op1
->
Input
(
f
::
GradVarName
(
"Y"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"y1"
)}));
EXPECT_EQ
(
grad_op1
->
Input
(
f
::
GradVarName
(
"Z"
)),
std
::
vector
<
std
::
string
>
({
std
::
string
(
"z1"
)
+
f
::
kZeroVarSuffix
}));
EXPECT_EQ
(
grad_op1
->
Output
(
f
::
GradVarName
(
"X"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"x1"
)}));
EXPECT_EQ
(
grad_op1
->
Output
(
f
::
GradVarName
(
"H"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"h1"
)}));
}
TEST
(
Backward
,
shared_var
)
{
f
::
ProgramDesc
*
program_desc
=
GetNewProgramDesc
();
f
::
ProgramDescBind
&
program
=
f
::
ProgramDescBind
::
Instance
(
program_desc
);
f
::
BlockDescBind
*
block
=
program
.
Block
(
0
);
f
::
OpDescBind
*
op1
=
block
->
AppendOp
();
op1
->
SetType
(
"rowwise_add"
);
op1
->
SetInput
(
"X"
,
{
"x1"
});
op1
->
SetInput
(
"b"
,
{
"b1"
});
op1
->
SetOutput
(
"Out"
,
{
"out1"
});
f
::
OpDescBind
*
op2
=
block
->
AppendOp
();
op2
->
SetType
(
"mul"
);
op2
->
SetInput
(
"X"
,
{
"out1"
});
op2
->
SetInput
(
"Y"
,
{
"y2"
});
op2
->
SetOutput
(
"Out"
,
{
"out2"
});
f
::
OpDescBind
*
op3
=
block
->
AppendOp
();
op3
->
SetType
(
"rowwise_add"
);
op3
->
SetInput
(
"X"
,
{
"out1"
});
op3
->
SetInput
(
"b"
,
{
"b3"
});
op3
->
SetOutput
(
"Out"
,
{
"out3"
});
AppendBackward
(
program
,
{});
ASSERT_EQ
(
block
->
AllOps
().
size
(),
7UL
);
f
::
OpDescBind
*
grad_op3
=
block
->
AllOps
()[
3
];
ASSERT_EQ
(
grad_op3
->
Type
(),
"rowwise_add_grad"
);
ASSERT_EQ
(
grad_op3
->
InputNames
().
size
(),
1UL
);
ASSERT_EQ
(
grad_op3
->
OutputNames
().
size
(),
2UL
);
EXPECT_EQ
(
grad_op3
->
Input
(
f
::
GradVarName
(
"Out"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out3"
)}));
EXPECT_EQ
(
grad_op3
->
Output
(
f
::
GradVarName
(
"X"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out1"
)
+
"@RENAME@0"
}));
EXPECT_EQ
(
grad_op3
->
Output
(
f
::
GradVarName
(
"b"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"b3"
)}));
f
::
OpDescBind
*
grad_op4
=
block
->
AllOps
()[
4
];
ASSERT_EQ
(
grad_op4
->
Type
(),
"mul_grad"
);
ASSERT_EQ
(
grad_op4
->
InputNames
().
size
(),
4UL
);
ASSERT_EQ
(
grad_op4
->
OutputNames
().
size
(),
2UL
);
EXPECT_EQ
(
grad_op4
->
Input
(
"X"
),
std
::
vector
<
std
::
string
>
({
"out1"
}));
EXPECT_EQ
(
grad_op4
->
Input
(
"Y"
),
std
::
vector
<
std
::
string
>
({
"y2"
}));
EXPECT_EQ
(
grad_op4
->
Input
(
"Out"
),
std
::
vector
<
std
::
string
>
({
"out2"
}));
EXPECT_EQ
(
grad_op4
->
Input
(
f
::
GradVarName
(
"Out"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out2"
)}));
EXPECT_EQ
(
grad_op4
->
Output
(
f
::
GradVarName
(
"X"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out1"
)
+
"@RENAME@1"
}));
EXPECT_EQ
(
grad_op4
->
Output
(
f
::
GradVarName
(
"Y"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"y2"
)}));
f
::
OpDescBind
*
sum_op
=
block
->
AllOps
()[
5
];
ASSERT_EQ
(
sum_op
->
Type
(),
"sum"
);
ASSERT_EQ
(
sum_op
->
InputNames
().
size
(),
1UL
);
ASSERT_EQ
(
sum_op
->
OutputNames
().
size
(),
1UL
);
EXPECT_EQ
(
sum_op
->
Input
(
"X"
),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out1"
)
+
"@RENAME@0"
,
f
::
GradVarName
(
"out1"
)
+
"@RENAME@1"
}));
EXPECT_EQ
(
sum_op
->
Output
(
"Out"
),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out1"
)}));
f
::
OpDescBind
*
grad_op1
=
block
->
AllOps
()[
6
];
ASSERT_EQ
(
grad_op1
->
Type
(),
"rowwise_add_grad"
);
ASSERT_EQ
(
grad_op1
->
InputNames
().
size
(),
1UL
);
ASSERT_EQ
(
grad_op1
->
OutputNames
().
size
(),
2UL
);
EXPECT_EQ
(
grad_op1
->
Input
(
f
::
GradVarName
(
"Out"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"out1"
)}));
EXPECT_EQ
(
grad_op1
->
Output
(
f
::
GradVarName
(
"X"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"x1"
)}));
EXPECT_EQ
(
grad_op1
->
Output
(
f
::
GradVarName
(
"b"
)),
std
::
vector
<
std
::
string
>
({
f
::
GradVarName
(
"b1"
)}));
}
\ No newline at end of file
paddle/framework/block_desc.h
浏览文件 @
c3b46d16
...
...
@@ -32,6 +32,14 @@ class ProgramDescBind;
class
BlockDescBind
{
public:
friend
std
::
vector
<
std
::
unique_ptr
<
OpDescBind
>>
MakeBlockBackward
(
ProgramDescBind
&
program_desc
,
int
block_idx
,
std
::
unordered_set
<
std
::
string
>
&
no_grad_vars
);
friend
void
AppendBackward
(
ProgramDescBind
&
program_desc
,
const
std
::
unordered_set
<
std
::
string
>
&
no_grad_vars
);
BlockDescBind
(
ProgramDescBind
*
prog
,
BlockDesc
*
desc
)
:
prog_
(
prog
),
desc_
(
desc
),
need_update_
(
false
)
{}
...
...
paddle/framework/op_desc.cc
浏览文件 @
c3b46d16
...
...
@@ -18,6 +18,15 @@ limitations under the License. */
namespace
paddle
{
namespace
framework
{
OpDescBind
::
OpDescBind
(
const
std
::
string
&
type
,
const
VariableNameMap
&
inputs
,
const
VariableNameMap
&
outputs
,
const
AttributeMap
&
attrs
)
{
op_desc_
.
set_type
(
type
);
inputs_
=
inputs
;
outputs_
=
outputs
;
attrs_
=
attrs
;
}
OpDesc
*
OpDescBind
::
Proto
()
{
Sync
();
return
&
op_desc_
;
...
...
@@ -31,6 +40,14 @@ const std::vector<std::string> &OpDescBind::Input(
return
it
->
second
;
}
std
::
vector
<
std
::
string
>
OpDescBind
::
InputArgumentNames
()
const
{
std
::
vector
<
std
::
string
>
retv
;
for
(
auto
&
ipt
:
this
->
inputs_
)
{
retv
.
insert
(
retv
.
end
(),
ipt
.
second
.
begin
(),
ipt
.
second
.
end
());
}
return
retv
;
}
void
OpDescBind
::
SetInput
(
const
std
::
string
&
param_name
,
const
std
::
vector
<
std
::
string
>
&
args
)
{
need_update_
=
true
;
...
...
@@ -45,6 +62,14 @@ const std::vector<std::string> &OpDescBind::Output(
return
it
->
second
;
}
std
::
vector
<
std
::
string
>
OpDescBind
::
OutputArgumentNames
()
const
{
std
::
vector
<
std
::
string
>
retv
;
for
(
auto
&
ipt
:
this
->
outputs_
)
{
retv
.
insert
(
retv
.
end
(),
ipt
.
second
.
begin
(),
ipt
.
second
.
end
());
}
return
retv
;
}
void
OpDescBind
::
SetOutput
(
const
std
::
string
&
param_name
,
const
std
::
vector
<
std
::
string
>
&
args
)
{
need_update_
=
true
;
...
...
@@ -94,6 +119,18 @@ const std::unordered_map<std::string, Attribute> &OpDescBind::GetAttrMap()
return
attrs_
;
}
void
OpDescBind
::
Rename
(
const
std
::
string
&
old_name
,
const
std
::
string
&
new_name
)
{
for
(
auto
&
input
:
inputs_
)
{
std
::
replace
(
input
.
second
.
begin
(),
input
.
second
.
end
(),
old_name
,
new_name
);
}
for
(
auto
&
output
:
outputs_
)
{
std
::
replace
(
output
.
second
.
begin
(),
output
.
second
.
end
(),
old_name
,
new_name
);
}
need_update_
=
true
;
}
struct
SetAttrDescVisitor
:
public
boost
::
static_visitor
<
void
>
{
explicit
SetAttrDescVisitor
(
OpDesc
::
Attr
*
attr
)
:
attr_
(
attr
)
{}
mutable
OpDesc
::
Attr
*
attr_
;
...
...
paddle/framework/op_desc.h
浏览文件 @
c3b46d16
...
...
@@ -27,6 +27,11 @@ class BlockDescBind;
class
OpDescBind
{
public:
OpDescBind
()
{}
OpDescBind
(
const
std
::
string
&
type
,
const
VariableNameMap
&
inputs
,
const
VariableNameMap
&
outputs
,
const
AttributeMap
&
attrs
);
OpDesc
*
Proto
();
std
::
string
Type
()
const
{
return
op_desc_
.
type
();
}
...
...
@@ -35,11 +40,15 @@ class OpDescBind {
const
std
::
vector
<
std
::
string
>
&
Input
(
const
std
::
string
&
name
)
const
;
std
::
vector
<
std
::
string
>
InputArgumentNames
()
const
;
void
SetInput
(
const
std
::
string
&
param_name
,
const
std
::
vector
<
std
::
string
>
&
args
);
const
std
::
vector
<
std
::
string
>
&
Output
(
const
std
::
string
&
name
)
const
;
std
::
vector
<
std
::
string
>
OutputArgumentNames
()
const
;
void
SetOutput
(
const
std
::
string
&
param_name
,
const
std
::
vector
<
std
::
string
>
&
args
);
...
...
@@ -61,6 +70,8 @@ class OpDescBind {
int
GetBlockAttr
(
const
std
::
string
&
name
)
const
;
void
Rename
(
const
std
::
string
&
old_name
,
const
std
::
string
&
new_name
);
// Only be used in C++
const
AttributeMap
&
GetAttrMap
()
const
;
...
...
paddle/framework/op_registry.cc
浏览文件 @
c3b46d16
...
...
@@ -59,5 +59,11 @@ std::unique_ptr<OperatorBase> OpRegistry::CreateOp(const OpDescBind& op_desc) {
op_desc
.
GetAttrMap
());
}
std
::
vector
<
std
::
unique_ptr
<
OpDescBind
>>
OpRegistry
::
CreateGradOpDescs
(
const
OpDescBind
&
op_desc
)
{
auto
&
info
=
OpInfoMap
::
Instance
().
Get
(
op_desc
.
Type
());
return
info
.
grad_op_maker_
(
op_desc
);
}
}
// namespace framework
}
// namespace paddle
paddle/framework/op_registry.h
浏览文件 @
c3b46d16
...
...
@@ -79,6 +79,9 @@ class OpRegistry {
static
std
::
unique_ptr
<
OperatorBase
>
CreateOp
(
const
OpDesc
&
op_desc
);
static
std
::
vector
<
std
::
unique_ptr
<
OpDescBind
>>
CreateGradOpDescs
(
const
OpDescBind
&
op_desc
);
static
std
::
unique_ptr
<
OperatorBase
>
CreateOp
(
const
OpDescBind
&
op_desc
);
};
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录