layer.py 10.8 KB
Newer Older
Q
qiaolongfei 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
"""
Before this new package paddle.v2.layer, users would need to use functions
in paddle.trainer_config_helpers.layers to configure networks.

The Old Way:
=========
This old way requires that the creation of a network be defined in a Python
function, say network_config, and that this Python function being passed to
paddle.trainer_config_helpers.parse_network_config for the creation of
protobuf message description of this network.

```python
def network_config():
  img = paddle.trainer_config_helpers.data_layer(name="pixel", size=784)
  inference = paddle.trainer_config_helpers.fc_layer(
    input=img,
    size=10,
    act=paddle.trainer_config_helpers.SoftmaxActivation())
  cost = paddle.trainer_config_helpers.classification_cost(
    input=inference,
    label=paddle.trainer_config_helpers.data_layer(name="label", size=10))

proto_desc = parse_network_config(network_config)
```

When parse_network_config executes network_config, those layer definition
functions like data_layer and fc_layer would change some Python global variables,
so that after the execution, parse_network_config could collect information from
these global variables and generates the protobuf message.



The New Way:
=========
In this PR, we define a function in paddle.v2.layer which creates a Python
class for each layer creation function in paddle.trainer_config_helpers.layers.
Users can use create a network as follows:

```python
img = paddle.v2.layer.data(name="pixel", size=784)
inference = paddle.v2.layer.fc(input=img, size=10, act=paddle.v2.layer.Softmax())
cost = paddle.v2.layer.classification(
  input=inference,
  label=paddle.v2.layer.data(name="label", size=10))

parameters = paddle.v2.parameters.create(cost)
```

This new way doesn't require those invocations to layer definition functions
to be in a Python function but could be anywhere.

Also, the creation of a protobuf message is hidden in the invocation of
paddle.v2.parameters.create, no longer exposed to users.
"""
Q
qiaolongfei 已提交
68

Q
qiaolongfei 已提交
69 70
import collections

Q
qiaolongfei 已提交
71 72 73
import paddle.trainer_config_helpers as conf_helps
from paddle.trainer_config_helpers.config_parser_utils import \
    parse_network_config as __parse__
D
dangqingqing 已提交
74

Q
qiaolongfei 已提交
75
from paddle.trainer_config_helpers.default_decorators import wrap_name_default
76 77 78
from paddle.trainer_config_helpers.default_decorators import wrap_act_default
from paddle.trainer_config_helpers.default_decorators import wrap_bias_attr_default
from paddle.trainer_config_helpers.layers import layer_support
Q
qiaolongfei 已提交
79 80

import data_type
L
Luo Tao 已提交
81 82
import activation
import attr
Q
qiaolongfei 已提交
83

Q
qiaolongfei 已提交
84
__all__ = [
D
dangqingqing 已提交
85 86 87 88
    'parse_network', 'data', 'fc', 'max_id', 'classification_cost',
    'cross_entropy_cost', 'cross_entropy_with_selfnorm_cost', 'regression_cost',
    'multi_binary_label_cross_entropy_cost', 'rank_cost', 'lambda_cost',
    'sum_cost', 'huber_cost'
Q
qiaolongfei 已提交
89 90
]

D
dangqingqing 已提交
91 92 93 94 95 96 97
__projection_names__ = filter(lambda x: x.endswith('_projection'),
                              dir(conf_helps))
__all__ += __projection_names__

__operator_names__ = filter(lambda x: x.endswith('_operator'), dir(conf_helps))
__all__ += __operator_names__

Q
qiaolongfei 已提交
98

Q
qiaolongfei 已提交
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
def parse_network(*outputs):
    """
    parse all output layers and then generate a model config proto.
    :param outputs:
    :return:
    """

    def __real_func__():
        context = dict()
        real_output = [each.to_proto(context=context) for each in outputs]
        conf_helps.outputs(real_output)

    return __parse__(__real_func__)


Q
qiaolongfei 已提交
114
class Layer(object):
115
    def __init__(self, name=None, parent_layers=None):
Q
qiaolongfei 已提交
116
        assert isinstance(parent_layers, dict)
Q
qiaolongfei 已提交
117
        self.name = name
Q
qiaolongfei 已提交
118
        self.__parent_layers__ = parent_layers
Q
qiaolongfei 已提交
119 120 121 122 123 124

    def to_proto(self, context):
        """
        function to set proto attribute
        """
        kwargs = dict()
Q
qiaolongfei 已提交
125 126
        for layer_name in self.__parent_layers__:
            if not isinstance(self.__parent_layers__[layer_name],
Q
qiaolongfei 已提交
127
                              collections.Sequence):
Q
qiaolongfei 已提交
128
                v1_layer = self.__parent_layers__[layer_name].to_proto(
Q
qiaolongfei 已提交
129 130
                    context=context)
            else:
Q
qiaolongfei 已提交
131 132 133
                v1_layer = map(lambda x: x.to_proto(context=context),
                               self.__parent_layers__[layer_name])
            kwargs[layer_name] = v1_layer
Q
qiaolongfei 已提交
134

135 136 137
        if self.name is None:
            return self.to_proto_impl(**kwargs)

Q
qiaolongfei 已提交
138 139 140 141 142 143 144 145
        if self.name not in context:
            context[self.name] = self.to_proto_impl(**kwargs)
        return context[self.name]

    def to_proto_impl(self, **kwargs):
        raise NotImplementedError()


146
def __convert_to_v2__(method_name, name_prefix=None, parent_names=None):
Q
qiaolongfei 已提交
147 148 149 150 151
    if name_prefix is not None:
        wrapper = wrap_name_default(name_prefix=name_prefix)
    else:
        wrapper = None

Q
qiaolongfei 已提交
152
    class V2LayerImpl(Layer):
D
dangqingqing 已提交
153
        def __init__(self, **kwargs):
Q
qiaolongfei 已提交
154 155 156
            parent_layers = dict()
            other_kwargs = dict()
            for pname in parent_names:
L
Luo Tao 已提交
157 158
                if kwargs.has_key(pname):
                    parent_layers[pname] = kwargs[pname]
Q
qiaolongfei 已提交
159 160 161 162 163

            for key in kwargs.keys():
                if key not in parent_names:
                    other_kwargs[key] = kwargs[key]

D
dangqingqing 已提交
164
            name = kwargs['name'] if kwargs.has_key('name') else None
Q
qiaolongfei 已提交
165
            super(V2LayerImpl, self).__init__(name, parent_layers)
Q
qiaolongfei 已提交
166 167 168 169 170 171 172 173 174 175 176
            self.__other_kwargs__ = other_kwargs

        if wrapper is not None:
            __init__ = wrapper(__init__)

        def to_proto_impl(self, **kwargs):
            args = dict()
            for each in kwargs:
                args[each] = kwargs[each]
            for each in self.__other_kwargs__:
                args[each] = self.__other_kwargs__[each]
177
            return getattr(conf_helps, method_name)(**args)
Q
qiaolongfei 已提交
178

Q
qiaolongfei 已提交
179
    return V2LayerImpl
Q
qiaolongfei 已提交
180 181


Q
qiaolongfei 已提交
182 183 184 185 186 187 188
"""
Some layer may need some special config, and can not use __convert_to_v2__ to convert.
So we also need to implement some special LayerV2.
"""


class DataLayerV2(Layer):
Q
qiaolongfei 已提交
189
    def __init__(self, name, type, **kwargs):
190
        assert isinstance(type, data_type.InputType)
Q
qiaolongfei 已提交
191

Q
qiaolongfei 已提交
192
        self.type = type
Q
qiaolongfei 已提交
193 194
        self.__method_name__ = 'data_layer'
        self.__kwargs__ = kwargs
Q
qiaolongfei 已提交
195 196 197 198 199

        super(DataLayerV2, self).__init__(name=name, parent_layers=dict())

    def to_proto_impl(self, **kwargs):
        args = dict()
Q
qiaolongfei 已提交
200
        args['size'] = self.type.dim
Q
qiaolongfei 已提交
201 202
        for each in kwargs:
            args[each] = kwargs[each]
Q
qiaolongfei 已提交
203 204
        for each in self.__kwargs__:
            args[each] = self.__kwargs__[each]
Q
qiaolongfei 已提交
205 206 207
        return getattr(conf_helps, self.__method_name__)(name=self.name, **args)


208 209 210 211 212 213 214 215 216 217
class MixedLayerV2(Layer):
    """
    This class is use to support `with` grammar. If not, the following code
    could convert mixed_layer simply.

        mixed = __convert_to_v2__(
            'mixed_layer', name_prefix='mixed', parent_names=['input'])
    """

    class AddToSealedMixedLayerExceptionV2(Exception):
D
dangqingqing 已提交
218
        pass
219 220 221 222 223 224 225 226 227 228

    def __init__(self,
                 size=0,
                 input=None,
                 name=None,
                 act=None,
                 bias_attr=None,
                 layer_attr=None):
        self.__method_name__ = 'mixed_layer'
        self.finalized = False
D
dangqingqing 已提交
229
        self.__inputs__ = []
230
        if input is not None:
D
dangqingqing 已提交
231
            self.__inputs__ = input
232

D
dangqingqing 已提交
233 234
        other_kwargs = dict()
        other_kwargs['name'] = name
235 236 237 238 239
        other_kwargs['size'] = size
        other_kwargs['act'] = act
        other_kwargs['bias_attr'] = bias_attr
        other_kwargs['layer_attr'] = layer_attr

D
dangqingqing 已提交
240 241
        parent_layers = {"input": self.__inputs__}
        super(MixedLayerV2, self).__init__(name, parent_layers)
242 243 244 245
        self.__other_kwargs__ = other_kwargs

    def __iadd__(self, other):
        if not self.finalized:
D
dangqingqing 已提交
246
            self.__inputs__.append(other)
247 248 249 250 251
            return self
        else:
            raise MixedLayerTypeV2.AddToSealedMixedLayerExceptionV2()

    def __enter__(self):
D
dangqingqing 已提交
252
        assert len(self.__inputs__) == 0
253 254 255 256 257 258 259 260 261 262 263
        return self

    def __exit__(self, *args, **kwargs):
        self.finalized = True

    def to_proto_impl(self, **kwargs):
        args = dict()
        for each in kwargs:
            args[each] = kwargs[each]
        for each in self.__other_kwargs__:
            args[each] = self.__other_kwargs__[each]
D
dangqingqing 已提交
264
        return getattr(conf_helps, self.__method_name__)(**args)
265 266 267


@wrap_name_default("mixed")
D
dangqingqing 已提交
268
@wrap_act_default(act=activation.Linear())
269 270 271 272 273 274 275 276 277 278 279
@wrap_bias_attr_default(has_bias=False)
@layer_support(conf_helps.layers.ERROR_CLIPPING, conf_helps.layers.DROPOUT)
def mixed(size=0,
          name=None,
          input=None,
          act=None,
          bias_attr=False,
          layer_attr=None):
    return MixedLayerV2(size, input, name, act, bias_attr, layer_attr)


Q
qiaolongfei 已提交
280
data = DataLayerV2
Q
qiaolongfei 已提交
281 282
fc = __convert_to_v2__('fc_layer', name_prefix='fc', parent_names=['input'])
max_id = __convert_to_v2__(
L
Luo Tao 已提交
283
    'maxid_layer', name_prefix='maxid', parent_names=['input'])
Q
qiaolongfei 已提交
284
classification_cost = __convert_to_v2__(
Q
qiaolongfei 已提交
285 286
    'classification_cost',
    name_prefix='classification_cost',
L
Luo Tao 已提交
287 288 289 290 291
    parent_names=['input', 'label', 'weight'])
regression_cost = __convert_to_v2__(
    'regression_cost',
    name_prefix='regression_cost',
    parent_names=['input', 'label', 'weight'])
Q
qiaolongfei 已提交
292 293 294 295
cross_entropy_cost = __convert_to_v2__(
    'cross_entropy',
    name_prefix='cross_entropy',
    parent_names=['input', 'label'])
L
Luo Tao 已提交
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
cross_entropy_with_selfnorm_cost = __convert_to_v2__(
    'cross_entropy_with_selfnorm',
    name_prefix='cross_entropy_with_selfnorm',
    parent_names=['input', 'label'])
multi_binary_label_cross_entropy_cost = __convert_to_v2__(
    'multi_binary_label_cross_entropy',
    name_prefix='multi_binary_label_cross_entropy',
    parent_names=['input', 'label'])
rank_cost = __convert_to_v2__(
    'rank_cost',
    name_prefix='rank_cost',
    parent_names=['left', 'right', 'label', 'weight'])
lambda_cost = __convert_to_v2__(
    'lambda_cost', name_prefix='lambda_cost', parent_names=['input', 'score'])
sum_cost = __convert_to_v2__(
    'sum_cost', name_prefix='sum_cost', parent_names=['input'])
huber_cost = __convert_to_v2__(
    'huber_cost', name_prefix='huber_cost', parent_names=['input', 'label'])
Q
qiaolongfei 已提交
314

315
# convert projection
D
dangqingqing 已提交
316
for prj in __projection_names__:
317 318 319 320 321 322 323 324 325 326
    globals()[prj] = __convert_to_v2__(prj, parent_names=['input'])

# convert operator
operator_list = [
    # [V1_method_name, parent_names],
    ['dotmul_operator', ['a', 'b']],
    ['conv_operator', ['img', 'filter']]
]
for op in operator_list:
    globals()[op[0]] = __convert_to_v2__(op[0], parent_names=op[1])