Skip to content

P
PARL

PaddlePaddle / PARL

通知 67
Star 3
Fork 0
P
PARL

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 ad049bca 编写于 作者: H haonanyu 提交者： emailweixu
浏览文件
操作

revisions

上级 b5965b47
隐藏空白更改
内联 并排
Showing with 66 addition and 163 deletion
README.md
浏览文件 @ ad049bca
# PPRL
PaddlePaddle Reinforcement Learning Framework
# PARL
**Pa**ddlePaddle **R**einforcement **L**earning Framework
pprl/layers/layer_wrappers.py → parl/layers/layer_wrappers.py
浏览文件 @ ad049bca
......@@ -18,6 +18,7 @@ Wrappers for fluid.layers so that the layers can share parameters conveniently.
from paddle.fluid.layers import *
from paddle.fluid.param_attr import ParamAttr
import paddle.fluid.layers as layers
import paddle.fluid.unique_name as unique_name
import warnings
import inspect
......@@ -28,21 +29,6 @@ all_wrapped_layers = [
]
class LayerCounter:
custom = {}
create_parameter = 0
fc = 0
embedding = 0
dynamic_lstm = 0
dynamic_lstmp = 0
dynamic_gru = 0
sequence_conv = 0
conv2d = 0
conv2d_transpose = 0
lstm_unit = 0
row_conv = 0
class LayerFunc(object):
def __init__(self, param_attr=False, bias_attr=False):
self.param_attr = param_attr
......@@ -62,90 +48,35 @@ class LayerFunc(object):
else:
return None
def parameters(self):
return (self.param_attr, self.bias_attr)
def get_set_paras(set_paras):
param_name, bias_name = None, None
if set_paras is not None:
assert (type(set_paras) is tuple) and len(set_paras) == 2
param_attr, bias_attr = set_paras
if param_attr:
param_name = param_attr.name
if bias_attr:
bias_name = bias_attr.name
return param_name, bias_name
def check_or_replace_name(name, new_name, attr):
name = (new_name if name is None else name)
## if this para is not used
if attr == False:
return False
if attr is None:
return ParamAttr(name=name)
assert attr.name is None, \
"Do not set parameter name for pprl.layers; leave it as None"
attr.name = name
return attr
def update_attr_name(name, param_name, field_name, attr, suffix,
counter_increase):
if name is None:
name = field_name
else:
name = "_" + name
field_name = "custom"
if field_name == "custom":
custom_counter = getattr(LayerCounter, field_name)
if not name in custom_counter:
custom_counter[name] = 0
idx = custom_counter[name]
if counter_increase:
custom_counter[name] += 1
setattr(LayerCounter, field_name, custom_counter)
else:
idx = getattr(LayerCounter, field_name)
if counter_increase:
setattr(LayerCounter, field_name, idx + 1)
new_name = "%s_%d%s" % (name, idx, suffix)
return check_or_replace_name(param_name, new_name, attr)
def create_parameter(shape,
dtype,
attr=None,
is_bias=False,
default_initializer=None,
name=None,
set_paras=None):
def update_attr_name(name, default_name, attr, is_bias):
"""
Return a function that creates paddle.fluid.layers.create_parameter.
Update the name in an attribute
1. If the user provides a name, then generate the candidate name using the
provided name;
2. else generate the candidate name using the default name (which should be
the name of the layer wrapper).
3. After obtaining the candidate name, if the attr is False, then we return False;
4. if the attr is None or attr.name is None, then we set the attr's name as the candidate name;
5. else we ignore the candidate name and do nothing.
"""
param_name, _ = get_set_paras(set_paras)
self_name = inspect.stack[0][3]
attr = update_attr_name(name, param_name, self_name, attr, ".w", True)
def check_or_replace_name(name, attr):
## if this para is not used
if attr == False:
return False
class CreateParameter_(LayerFunc):
def __init__(self):
super(CreateParameter_, self).__init__(attr)
if attr is None:
return ParamAttr(name=name)
def __call__(self):
return layers.create_parameter(
shape=shape,
dtype=dtype,
attr=attr,
is_bias=is_bias,
default_initializer=default_initializer)
if attr.name is None:
attr.name = name
return attr
return CreateParameter_()
name = (default_name if name is None else name)
suffix = "b" if is_bias else "w"
new_name = unique_name.generate(name + "." + suffix)
return check_or_replace_name(new_name, attr)
def fc(size,
......@@ -160,12 +91,9 @@ def fc(size,
"""
Return a function that creates a paddle.fluid.layers.fc.
"""
param_name, bias_name = get_set_paras(set_paras)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
default_name = "fc"
param_attr = update_attr_name(name, default_name, param_attr, False)
bias_attr = update_attr_name(name, default_name, bias_attr, True)
class FC_(LayerFunc):
def __init__(self):
......@@ -195,10 +123,7 @@ def embedding(size,
"""
Return a function that creates a paddle.fluid.layers.embedding.
"""
param_name, _ = get_set_paras(set_paras)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", True)
param_attr = update_attr_name(name, "embedding", param_attr, False)
class Embedding_(LayerFunc):
def __init__(self):
......@@ -231,12 +156,9 @@ def dynamic_lstm(size,
"""
Return a function that creates a paddle.fluid.layers.dynamic_lstm.
"""
param_name, bias_name = get_set_paras(set_paras)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
default_name = "dynamic_lstm"
param_attr = update_attr_name(name, default_name, param_attr, False)
bias_attr = update_attr_name(name, default_name, bias_attr, True)
class DynamicLstm_(LayerFunc):
def __init__(self):
......@@ -274,12 +196,9 @@ def dynamic_lstmp(size,
"""
Return a function that creates a paddle.fluid.layers.dynamic_lstmp.
"""
param_name, bias_name = get_set_paras(set_paras)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
default_name = "dynamic_lstmp"
param_attr = update_attr_name(name, default_name, param_attr, False)
bias_attr = update_attr_name(name, default_name, bias_attr, True)
class DynamicLstmp_(LayerFunc):
def __init__(self):
......@@ -315,12 +234,9 @@ def dynamic_gru(size,
"""
Return a function that creates a paddle.fluid.layers.dynamic_gru.
"""
param_name, bias_name = get_set_paras(set_paras)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
default_name = "dynamic_gru"
param_attr = update_attr_name(name, default_name, param_attr, False)
bias_attr = update_attr_name(name, default_name, bias_attr, True)
class DynamicGru_(LayerFunc):
def __init__(self):
......@@ -367,12 +283,9 @@ def sequence_conv(num_filters,
"""
Return a function that creates a paddle.fluid.layers.sequence_conv.
"""
param_name, bias_name = get_set_paras(set_paras)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
default_name = "sequence_conv"
param_attr = update_attr_name(name, default_name, param_attr, False)
bias_attr = update_attr_name(name, default_name, bias_attr, True)
class SequenceConv_(LayerFunc):
def __init__(self):
......@@ -408,12 +321,9 @@ def conv2d(num_filters,
"""
Return a function that creates a paddle.fluid.layers.conv2d.
"""
param_name, bias_name = get_set_paras(set_paras)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
default_name = "conv2d"
param_attr = update_attr_name(name, default_name, param_attr, False)
bias_attr = update_attr_name(name, default_name, bias_attr, True)
class Conv2D_(LayerFunc):
def __init__(self):
......@@ -452,12 +362,9 @@ def conv2d_transpose(num_filters,
"""
Return a function that creates a paddle.fluid.layers.conv2d_transpose.
"""
param_name, bias_name = get_set_paras(set_paras)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
default_name = "conv2d_transpose"
param_attr = update_attr_name(name, default_name, param_attr, False)
bias_attr = update_attr_name(name, default_name, bias_attr, True)
class Conv2DTranspose_(LayerFunc):
def __init__(self):
......@@ -488,12 +395,9 @@ def lstm_unit(forget_bias=0.0,
"""
Return a function that creates a paddle.fluid.layers.lstm_unit.
"""
param_name, bias_name = get_set_paras(set_paras)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
default_name = "lstm_unit"
param_attr = update_attr_name(name, default_name, param_attr, False)
bias_attr = update_attr_name(name, default_name, bias_attr, True)
class LstmUnit_(LayerFunc):
def __init__(self):
......@@ -523,10 +427,7 @@ def row_conv(future_context_size,
"""
Return a function that creates a paddle.fluid.layers.row_conv.
"""
param_name, _ = get_set_paras(set_paras)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", True)
param_attr = update_attr_name(name, "row_conv", param_attr, False)
class RowConv_(LayerFunc):
def __init__(self):
......
pprl/layers/tests/test_param_name.py → parl/layers/tests/test_param_name.py
浏览文件 @ ad049bca
......@@ -26,42 +26,44 @@ class TestParamName(unittest.TestCase):
self.embedding = layers.embedding((100, 128))
self.embedding_custom = layers.embedding(
(100, 128), name="embedding_custom")
## although here self.conv2d shares param with self.embedding,
## it might be invalid because the param sizes do not match
self.conv2d = layers.conv2d(
num_filters=64,
filter_size=3,
name="my_conv2d",
set_paras=self.embedding.parameters())
param_attr=self.embedding.param_attr,
name="my_conv2d")
self.dynamic_grus = []
for i in range(5):
self.dynamic_grus.append(layers.dynamic_gru(50))
## fc1 and fc2 have different parameters
self.assertEqual(self.fc1.param_name, "fc_0.w")
self.assertEqual(self.fc2.param_name, "fc_1.w")
self.assertEqual(self.fc1.param_name, "fc.w_0")
self.assertEqual(self.fc2.param_name, "fc.w_1")
## fc3 has no bias and fc4 has no param; so the names are None
self.assertEqual(self.fc3.bias_name, None)
self.assertEqual(self.fc4.param_name, None)
self.assertEqual(self.fc4.bias_name, "fc.b_3")
## fc5 has a custom name without a bias
## fc5 has a different param name with fc1
self.assertEqual(self.fc5.param_name, "_fc_0.w")
self.assertEqual(self.fc5.param_name, "fc.w_4")
self.assertEqual(self.fc5.bias_name, None)
## embedding layer has no bias
self.assertEqual(self.embedding.param_name, "embedding_0.w")
self.assertEqual(self.embedding.param_name, "embedding.w_0")
self.assertEqual(self.embedding.bias_name, None)
## embedding layer with a custom name
self.assertEqual(self.embedding_custom.param_name,
"_embedding_custom_0.w")
"embedding_custom.w_0")
## conv2d shares param with embedding; has a custom bias name
self.assertEqual(self.conv2d.param_name, "embedding_0.w")
self.assertEqual(self.conv2d.bias_name, "_my_conv2d_0.wbias")
self.assertEqual(self.conv2d.param_name, "embedding.w_0")
self.assertEqual(self.conv2d.bias_name, "my_conv2d.b_0")
for i, gru in enumerate(self.dynamic_grus):
self.assertEqual(gru.param_name, "dynamic_gru_%d.w" % i)
self.assertEqual(gru.param_name, "dynamic_gru.w_%d" % i)
if __name__ == '__main__':
......
pprl/layers/tests/test_param_sharing.py → parl/layers/tests/test_param_sharing.py
浏览文件 @ ad049bca
......@@ -27,7 +27,7 @@ class TestParamSharing(unittest.TestCase):
self.fc4 = layers.fc(64, name="fc")
## we bind the paras of self.embedding to those of self.fc1
self.embedding = layers.embedding(
(100, 64), set_paras=self.fc1.parameters())
(100, 64), param_attr=self.fc1.param_attr)
def test_param_sharing(self):
"""
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或