config_base.py 6.6 KB
Newer Older
Y
Yu Yang 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14
# 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.

Y
Yu Yang 已提交
15
import collections
Y
Yu Yang 已提交
16
import re
Y
Yu Yang 已提交
17 18 19 20
from paddle.trainer_config_helpers.default_decorators import wrap_name_default
import paddle.trainer_config_helpers as conf_helps


Y
Yu Yang 已提交
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
class LayerType(type):
    def __new__(cls, name, bases, attrs):
        method_name = attrs.get('METHOD_NAME', None)
        if method_name is not None:
            method = getattr(conf_helps, method_name)
            if method.__doc__ is not None:
                mapper = attrs.get("__map_docstr__", None)
                if mapper is not None:
                    attrs['__doc__'] = LayerType.__map_docstr__(
                        mapper(method.__doc__),
                        method_name=method_name,
                        name=name)
                else:
                    attrs['__doc__'] = LayerType.__map_docstr__(
                        method.__doc__, method_name=method_name, name=name)
        return super(LayerType, cls).__new__(cls, name, bases, attrs)

    @staticmethod
    def __map_docstr__(doc, name, method_name):
        assert isinstance(doc, basestring)

        # replace LayerOutput to paddle.v2.config_base.Layer
        doc = doc.replace("LayerOutput", "paddle.v2.config_base.Layer")

Y
Yu Yang 已提交
45 46 47 48 49 50
        doc = doc.replace('ParameterAttribute',
                          'paddle.v2.attr.ParameterAttribute')

        doc = re.sub(r'ExtraLayerAttribute[^\s]?',
                     'paddle.v2.attr.ExtraAttribute', doc)

Y
Yu Yang 已提交
51 52 53 54 55 56 57 58 59 60 61
        # xxx_layer to xxx
        doc = re.sub(r"(?P<name>[a-z]+)_layer", r"\g<name>", doc)

        # XxxxActivation to paddle.v2.Activation.Xxxx
        doc = re.sub(r"(?P<name>[A-Z][a-zA-Z]+)Activation",
                     r"paddle.v2.Activation.\g<name>", doc)

        # TODO(yuyang18): Add more rules if needed.
        return doc


Y
Yu Yang 已提交
62
class Layer(object):
Y
Yu Yang 已提交
63 64
    __metaclass__ = LayerType

Q
qiaolongfei 已提交
65
    def __init__(self, name=None, parent_layers=None):
Y
Yu Yang 已提交
66 67
        assert isinstance(parent_layers, dict)
        self.name = name
Y
Yu Yang 已提交
68
        self.__context__ = {}
Y
Yu Yang 已提交
69
        self.__parent_layers__ = parent_layers
Y
Yu Yang 已提交
70 71 72 73
        self.__children_layers__ = []  # used for evaluator.

    def append_child(self, layer, parent_names):
        self.__children_layers__.append((layer, parent_names))
Y
Yu Yang 已提交
74 75 76 77 78

    def to_proto(self, context):
        """
        function to set proto attribute
        """
Y
Yu Yang 已提交
79 80 81 82 83 84 85 86 87 88
        self.__context__ = context

        # short cut if myself is parsed before.
        if self.context_name() in context:
            if self.use_context_name():
                return context[self.context_name()]
            else:
                return context[self.name]

        # parse parent before myself
Y
Yu Yang 已提交
89 90 91 92 93 94 95 96 97 98 99
        kwargs = dict()
        for layer_name in self.__parent_layers__:
            if not isinstance(self.__parent_layers__[layer_name],
                              collections.Sequence):
                v1_layer = self.__parent_layers__[layer_name].to_proto(
                    context=context)
            else:
                v1_layer = map(lambda x: x.to_proto(context=context),
                               self.__parent_layers__[layer_name])
            kwargs[layer_name] = v1_layer

Y
Yu Yang 已提交
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
        # parse myself.
        ret_val = self.to_proto_impl(**kwargs)
        if self.context_name() is not None:
            assert self.context_name() not in context
            # add myself to context
            context[self.context_name()] = ret_val

        # parse children.
        for layer, pnames in self.__children_layers__:
            drop = False

            # child will only be parsed if all parents are in context.
            for pname in pnames:
                if pname not in context:
                    drop = True
                    break
            if drop:
                continue
            layer.to_proto(context=context)

        return ret_val
Y
Yu Yang 已提交
121 122 123 124

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

Q
qiaolongfei 已提交
125 126 127 128 129 130 131 132 133 134 135
    def context_name(self):
        """
        Context name means the context which stores `to_proto_impl` result.
        If multiple layer share same context_name, the `to_proto_impl` of them
        will be invoked only once.
        """
        return self.name

    def use_context_name(self):
        return False

Q
qiaolongfei 已提交
136 137 138 139 140 141
    def calculate_size(self):
        """
        lazy calculate size of the layer, should be called when to_proto_impl of
        this layer is called.
        :return:
        """
Y
Yu Yang 已提交
142
        return self.__context__[self.context_name()].size
Q
qiaolongfei 已提交
143

Y
Yu Yang 已提交
144

Y
Yu Yang 已提交
145 146 147 148
def __convert_to_v2__(method_name,
                      parent_names,
                      is_default_name=True,
                      attach_parent=False):
Y
Yu Yang 已提交
149 150 151 152 153 154
    if is_default_name:
        wrapper = wrap_name_default(name_prefix=method_name)
    else:
        wrapper = None

    class V2LayerImpl(Layer):
Y
Yu Yang 已提交
155 156
        METHOD_NAME = method_name

Y
Yu Yang 已提交
157 158 159 160
        def __init__(self, **kwargs):
            parent_layers = dict()
            other_kwargs = dict()
            for pname in parent_names:
Y
Yu Yang 已提交
161
                if pname in kwargs:
Y
Yu Yang 已提交
162 163
                    parent_layers[pname] = kwargs[pname]

Y
Yu Yang 已提交
164
            if attach_parent:
Y
Yu Yang 已提交
165
                pnames = [x.context_name() for x in parent_layers.values()]
Y
Yu Yang 已提交
166 167 168 169 170 171 172 173 174

                for pname in parent_layers:
                    layers = kwargs[pname]
                    if not isinstance(layers, collections.Sequence):
                        layers = [layers]

                    for layer in layers:
                        layer.append_child(self, pnames)

Y
Yu Yang 已提交
175 176 177 178 179
            for key in kwargs.keys():
                if key not in parent_names:
                    other_kwargs[key] = kwargs[key]

            name = kwargs.get('name', None)
Q
qiaolongfei 已提交
180
            super(V2LayerImpl, self).__init__(name, parent_layers)
Y
Yu Yang 已提交
181 182 183 184 185 186 187 188 189 190 191 192 193 194
            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)(**args)

    return V2LayerImpl