Skip to content

P
PARL

PaddlePaddle / PARL

通知 68
Star 3
Fork 0
P
PARL
提交 ad049bca 编写于 作者: H haonanyu 提交者： emailweixu
浏览文件
操作

revisions

上级 b5965b47
隐藏空白更改
内联 并排
Showing with 66 addition and 163 deletion
README.md
浏览文件 @ ad049bca
# PPRL # PARL
PaddlePaddle Reinforcement Learning Framework **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. ...@@ -18,6 +18,7 @@ Wrappers for fluid.layers so that the layers can share parameters conveniently.
from paddle.fluid.layers import * from paddle.fluid.layers import *
from paddle.fluid.param_attr import ParamAttr from paddle.fluid.param_attr import ParamAttr
import paddle.fluid.layers as layers import paddle.fluid.layers as layers
import paddle.fluid.unique_name as unique_name
import warnings import warnings
import inspect import inspect
...@@ -28,21 +29,6 @@ all_wrapped_layers = [ ...@@ -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): class LayerFunc(object):
def __init__(self, param_attr=False, bias_attr=False): def __init__(self, param_attr=False, bias_attr=False):
self.param_attr = param_attr self.param_attr = param_attr
...@@ -62,90 +48,35 @@ class LayerFunc(object): ...@@ -62,90 +48,35 @@ class LayerFunc(object):
else: else:
return None return None
def parameters(self):
return (self.param_attr, self.bias_attr) def update_attr_name(name, default_name, attr, is_bias):
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):
""" """
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) def check_or_replace_name(name, attr):
self_name = inspect.stack[0][3] ## if this para is not used
attr = update_attr_name(name, param_name, self_name, attr, ".w", True) if attr == False:
return False
class CreateParameter_(LayerFunc): if attr is None:
def __init__(self): return ParamAttr(name=name)
super(CreateParameter_, self).__init__(attr)
def __call__(self): if attr.name is None:
return layers.create_parameter( attr.name = name
shape=shape, return attr
dtype=dtype,
attr=attr,
is_bias=is_bias,
default_initializer=default_initializer)
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, def fc(size,
...@@ -160,12 +91,9 @@ def fc(size, ...@@ -160,12 +91,9 @@ def fc(size,
""" """
Return a function that creates a paddle.fluid.layers.fc. Return a function that creates a paddle.fluid.layers.fc.
""" """
param_name, bias_name = get_set_paras(set_paras) default_name = "fc"
self_name = inspect.stack()[0][3] param_attr = update_attr_name(name, default_name, param_attr, False)
param_attr = update_attr_name(name, param_name, self_name, param_attr, bias_attr = update_attr_name(name, default_name, bias_attr, True)
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
class FC_(LayerFunc): class FC_(LayerFunc):
def __init__(self): def __init__(self):
...@@ -195,10 +123,7 @@ def embedding(size, ...@@ -195,10 +123,7 @@ def embedding(size,
""" """
Return a function that creates a paddle.fluid.layers.embedding. Return a function that creates a paddle.fluid.layers.embedding.
""" """
param_name, _ = get_set_paras(set_paras) param_attr = update_attr_name(name, "embedding", param_attr, False)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", True)
class Embedding_(LayerFunc): class Embedding_(LayerFunc):
def __init__(self): def __init__(self):
...@@ -231,12 +156,9 @@ def dynamic_lstm(size, ...@@ -231,12 +156,9 @@ def dynamic_lstm(size,
""" """
Return a function that creates a paddle.fluid.layers.dynamic_lstm. Return a function that creates a paddle.fluid.layers.dynamic_lstm.
""" """
param_name, bias_name = get_set_paras(set_paras) default_name = "dynamic_lstm"
self_name = inspect.stack()[0][3] param_attr = update_attr_name(name, default_name, param_attr, False)
param_attr = update_attr_name(name, param_name, self_name, param_attr, bias_attr = update_attr_name(name, default_name, bias_attr, True)
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
class DynamicLstm_(LayerFunc): class DynamicLstm_(LayerFunc):
def __init__(self): def __init__(self):
...@@ -274,12 +196,9 @@ def dynamic_lstmp(size, ...@@ -274,12 +196,9 @@ def dynamic_lstmp(size,
""" """
Return a function that creates a paddle.fluid.layers.dynamic_lstmp. Return a function that creates a paddle.fluid.layers.dynamic_lstmp.
""" """
param_name, bias_name = get_set_paras(set_paras) default_name = "dynamic_lstmp"
self_name = inspect.stack()[0][3] param_attr = update_attr_name(name, default_name, param_attr, False)
param_attr = update_attr_name(name, param_name, self_name, param_attr, bias_attr = update_attr_name(name, default_name, bias_attr, True)
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
class DynamicLstmp_(LayerFunc): class DynamicLstmp_(LayerFunc):
def __init__(self): def __init__(self):
...@@ -315,12 +234,9 @@ def dynamic_gru(size, ...@@ -315,12 +234,9 @@ def dynamic_gru(size,
""" """
Return a function that creates a paddle.fluid.layers.dynamic_gru. Return a function that creates a paddle.fluid.layers.dynamic_gru.
""" """
param_name, bias_name = get_set_paras(set_paras) default_name = "dynamic_gru"
self_name = inspect.stack()[0][3] param_attr = update_attr_name(name, default_name, param_attr, False)
param_attr = update_attr_name(name, param_name, self_name, param_attr, bias_attr = update_attr_name(name, default_name, bias_attr, True)
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
class DynamicGru_(LayerFunc): class DynamicGru_(LayerFunc):
def __init__(self): def __init__(self):
...@@ -367,12 +283,9 @@ def sequence_conv(num_filters, ...@@ -367,12 +283,9 @@ def sequence_conv(num_filters,
""" """
Return a function that creates a paddle.fluid.layers.sequence_conv. Return a function that creates a paddle.fluid.layers.sequence_conv.
""" """
param_name, bias_name = get_set_paras(set_paras) default_name = "sequence_conv"
self_name = inspect.stack()[0][3] param_attr = update_attr_name(name, default_name, param_attr, False)
param_attr = update_attr_name(name, param_name, self_name, param_attr, bias_attr = update_attr_name(name, default_name, bias_attr, True)
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
class SequenceConv_(LayerFunc): class SequenceConv_(LayerFunc):
def __init__(self): def __init__(self):
...@@ -408,12 +321,9 @@ def conv2d(num_filters, ...@@ -408,12 +321,9 @@ def conv2d(num_filters,
""" """
Return a function that creates a paddle.fluid.layers.conv2d. Return a function that creates a paddle.fluid.layers.conv2d.
""" """
param_name, bias_name = get_set_paras(set_paras) default_name = "conv2d"
self_name = inspect.stack()[0][3] param_attr = update_attr_name(name, default_name, param_attr, False)
param_attr = update_attr_name(name, param_name, self_name, param_attr, bias_attr = update_attr_name(name, default_name, bias_attr, True)
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
class Conv2D_(LayerFunc): class Conv2D_(LayerFunc):
def __init__(self): def __init__(self):
...@@ -452,12 +362,9 @@ def conv2d_transpose(num_filters, ...@@ -452,12 +362,9 @@ def conv2d_transpose(num_filters,
""" """
Return a function that creates a paddle.fluid.layers.conv2d_transpose. Return a function that creates a paddle.fluid.layers.conv2d_transpose.
""" """
param_name, bias_name = get_set_paras(set_paras) default_name = "conv2d_transpose"
self_name = inspect.stack()[0][3] param_attr = update_attr_name(name, default_name, param_attr, False)
param_attr = update_attr_name(name, param_name, self_name, param_attr, bias_attr = update_attr_name(name, default_name, bias_attr, True)
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
class Conv2DTranspose_(LayerFunc): class Conv2DTranspose_(LayerFunc):
def __init__(self): def __init__(self):
...@@ -488,12 +395,9 @@ def lstm_unit(forget_bias=0.0, ...@@ -488,12 +395,9 @@ def lstm_unit(forget_bias=0.0,
""" """
Return a function that creates a paddle.fluid.layers.lstm_unit. Return a function that creates a paddle.fluid.layers.lstm_unit.
""" """
param_name, bias_name = get_set_paras(set_paras) default_name = "lstm_unit"
self_name = inspect.stack()[0][3] param_attr = update_attr_name(name, default_name, param_attr, False)
param_attr = update_attr_name(name, param_name, self_name, param_attr, bias_attr = update_attr_name(name, default_name, bias_attr, True)
".w", False)
bias_attr = update_attr_name(name, bias_name, self_name, bias_attr,
".wbias", True)
class LstmUnit_(LayerFunc): class LstmUnit_(LayerFunc):
def __init__(self): def __init__(self):
...@@ -523,10 +427,7 @@ def row_conv(future_context_size, ...@@ -523,10 +427,7 @@ def row_conv(future_context_size,
""" """
Return a function that creates a paddle.fluid.layers.row_conv. Return a function that creates a paddle.fluid.layers.row_conv.
""" """
param_name, _ = get_set_paras(set_paras) param_attr = update_attr_name(name, "row_conv", param_attr, False)
self_name = inspect.stack()[0][3]
param_attr = update_attr_name(name, param_name, self_name, param_attr,
".w", True)
class RowConv_(LayerFunc): class RowConv_(LayerFunc):
def __init__(self): 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): ...@@ -26,42 +26,44 @@ class TestParamName(unittest.TestCase):
self.embedding = layers.embedding((100, 128)) self.embedding = layers.embedding((100, 128))
self.embedding_custom = layers.embedding( self.embedding_custom = layers.embedding(
(100, 128), name="embedding_custom") (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( self.conv2d = layers.conv2d(
num_filters=64, num_filters=64,
filter_size=3, filter_size=3,
name="my_conv2d", param_attr=self.embedding.param_attr,
set_paras=self.embedding.parameters()) name="my_conv2d")
self.dynamic_grus = [] self.dynamic_grus = []
for i in range(5): for i in range(5):
self.dynamic_grus.append(layers.dynamic_gru(50)) self.dynamic_grus.append(layers.dynamic_gru(50))
## fc1 and fc2 have different parameters ## fc1 and fc2 have different parameters
self.assertEqual(self.fc1.param_name, "fc_0.w") self.assertEqual(self.fc1.param_name, "fc.w_0")
self.assertEqual(self.fc2.param_name, "fc_1.w") self.assertEqual(self.fc2.param_name, "fc.w_1")
## fc3 has no bias and fc4 has no param; so the names are None ## fc3 has no bias and fc4 has no param; so the names are None
self.assertEqual(self.fc3.bias_name, None) self.assertEqual(self.fc3.bias_name, None)
self.assertEqual(self.fc4.param_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 custom name without a bias
## fc5 has a different param name with fc1 self.assertEqual(self.fc5.param_name, "fc.w_4")
self.assertEqual(self.fc5.param_name, "_fc_0.w")
self.assertEqual(self.fc5.bias_name, None) self.assertEqual(self.fc5.bias_name, None)
## embedding layer has no bias ## 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) self.assertEqual(self.embedding.bias_name, None)
## embedding layer with a custom name ## embedding layer with a custom name
self.assertEqual(self.embedding_custom.param_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 ## conv2d shares param with embedding; has a custom bias name
self.assertEqual(self.conv2d.param_name, "embedding_0.w") self.assertEqual(self.conv2d.param_name, "embedding.w_0")
self.assertEqual(self.conv2d.bias_name, "_my_conv2d_0.wbias") self.assertEqual(self.conv2d.bias_name, "my_conv2d.b_0")
for i, gru in enumerate(self.dynamic_grus): 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__': 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): ...@@ -27,7 +27,7 @@ class TestParamSharing(unittest.TestCase):
self.fc4 = layers.fc(64, name="fc") self.fc4 = layers.fc(64, name="fc")
## we bind the paras of self.embedding to those of self.fc1 ## we bind the paras of self.embedding to those of self.fc1
self.embedding = layers.embedding( self.embedding = layers.embedding(
(100, 64), set_paras=self.fc1.parameters()) (100, 64), param_attr=self.fc1.param_attr)
def test_param_sharing(self): def test_param_sharing(self):
""" """
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或