layer.py 7.2 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 69

import paddle.trainer_config_helpers as conf_helps
Q
qiaolongfei 已提交
70
import paddle.trainer.PyDataProvider2 as dp
Q
qiaolongfei 已提交
71 72 73 74 75
from paddle.trainer_config_helpers.config_parser_utils import \
    parse_network_config as __parse__
from paddle.trainer_config_helpers.default_decorators import wrap_name_default
import collections

Q
qiaolongfei 已提交
76 77 78 79 80
__all__ = [
    'parse_network', 'data', 'fc', 'max_id', 'classification_cost',
    'cross_entropy_cost'
]

Q
qiaolongfei 已提交
81

Q
qiaolongfei 已提交
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
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 已提交
97
class Layer(object):
Q
qiaolongfei 已提交
98 99
    def __init__(self, name, parent_layers):
        assert isinstance(parent_layers, dict)
Q
qiaolongfei 已提交
100 101
        assert isinstance(name, basestring)
        self.name = name
Q
qiaolongfei 已提交
102
        self.__parent_layers__ = parent_layers
Q
qiaolongfei 已提交
103 104 105 106 107 108

    def to_proto(self, context):
        """
        function to set proto attribute
        """
        kwargs = dict()
Q
qiaolongfei 已提交
109 110
        for layer_name in self.__parent_layers__:
            if not isinstance(self.__parent_layers__[layer_name],
Q
qiaolongfei 已提交
111
                              collections.Sequence):
Q
qiaolongfei 已提交
112
                v1_layer = self.__parent_layers__[layer_name].to_proto(
Q
qiaolongfei 已提交
113 114
                    context=context)
            else:
Q
qiaolongfei 已提交
115 116 117
                v1_layer = map(lambda x: x.to_proto(context=context),
                               self.__parent_layers__[layer_name])
            kwargs[layer_name] = v1_layer
Q
qiaolongfei 已提交
118 119 120 121 122 123 124 125 126

        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()


Q
qiaolongfei 已提交
127
def __convert_to_v2__(method_name, name_prefix, parent_names):
Q
qiaolongfei 已提交
128 129 130 131 132
    if name_prefix is not None:
        wrapper = wrap_name_default(name_prefix=name_prefix)
    else:
        wrapper = None

Q
qiaolongfei 已提交
133
    class V2LayerImpl(Layer):
Q
qiaolongfei 已提交
134 135 136 137 138 139 140 141 142 143
        def __init__(self, name=None, **kwargs):
            parent_layers = dict()
            other_kwargs = dict()
            for pname in parent_names:
                parent_layers[pname] = kwargs[pname]

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

Q
qiaolongfei 已提交
144
            super(V2LayerImpl, self).__init__(name, parent_layers)
Q
qiaolongfei 已提交
145 146 147 148 149 150 151 152 153 154 155 156 157
            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]
            return getattr(conf_helps, method_name)(name=self.name, **args)

Q
qiaolongfei 已提交
158
    return V2LayerImpl
Q
qiaolongfei 已提交
159 160


Q
qiaolongfei 已提交
161 162 163 164 165 166 167
"""
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 已提交
168 169
    def __init__(self, name, data_type, **kwargs):
        assert isinstance(data_type, dp.InputType)
Q
qiaolongfei 已提交
170

Q
qiaolongfei 已提交
171
        self.data_type = data_type
Q
qiaolongfei 已提交
172 173
        self.__method_name__ = 'data_layer'
        self.__kwargs__ = kwargs
Q
qiaolongfei 已提交
174 175 176 177 178

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

    def to_proto_impl(self, **kwargs):
        args = dict()
Q
qiaolongfei 已提交
179
        args['size'] = self.data_type.dim
Q
qiaolongfei 已提交
180 181
        for each in kwargs:
            args[each] = kwargs[each]
Q
qiaolongfei 已提交
182 183
        for each in self.__kwargs__:
            args[each] = self.__kwargs__[each]
Q
qiaolongfei 已提交
184 185 186 187
        return getattr(conf_helps, self.__method_name__)(name=self.name, **args)


data = DataLayerV2
Q
qiaolongfei 已提交
188 189 190 191
fc = __convert_to_v2__('fc_layer', name_prefix='fc', parent_names=['input'])
max_id = __convert_to_v2__(
    'maxid_layer', name_prefix='maxid_layer', parent_names=['input'])
classification_cost = __convert_to_v2__(
Q
qiaolongfei 已提交
192 193 194
    'classification_cost',
    name_prefix='classification_cost',
    parent_names=['input', 'label'])
Q
qiaolongfei 已提交
195 196 197 198
cross_entropy_cost = __convert_to_v2__(
    'cross_entropy',
    name_prefix='cross_entropy',
    parent_names=['input', 'label'])
Q
qiaolongfei 已提交
199 200

if __name__ == '__main__':
Q
qiaolongfei 已提交
201 202
    pixel = data(name='pixel', data_type=dp.dense_vector(784))
    label = data(name='label', data_type=dp.integer_value(10))
Q
qiaolongfei 已提交
203 204 205 206 207 208 209 210 211 212 213
    hidden = fc(input=pixel, size=100, act=conf_helps.SigmoidActivation())
    inference = fc(input=hidden, size=10, act=conf_helps.SoftmaxActivation())
    maxid = max_id(input=inference)
    cost1 = classification_cost(input=inference, label=label)
    cost2 = cross_entropy_cost(input=inference, label=label)

    print parse_network(cost1)
    print parse_network(cost2)
    print parse_network(cost1, cost2)
    print parse_network(cost2)
    print parse_network(inference, maxid)