parameters.py 8.2 KB
Newer Older
Y
Yu Yang 已提交
1
import numpy as np
Q
qiaolongfei 已提交
2
from . import layer as v2_layer
Y
Yu Yang 已提交
3
import py_paddle.swig_paddle as api
Q
qiaolongfei 已提交
4
from paddle.proto.ParameterConfig_pb2 import ParameterConfig
Y
Yu Yang 已提交
5

Y
Yu Yang 已提交
6
__all__ = ['Parameters', 'create']
Y
Yu Yang 已提交
7 8


Q
qiaolongfei 已提交
9
def create(*layers):
Y
Yu Yang 已提交
10
    """
Q
qiaolongfei 已提交
11 12
    Create parameter pool by layers. In paddle, layer can be represent a
    model config.
Y
Yu Yang 已提交
13

Q
qiaolongfei 已提交
14
    :param layers:
Y
Yu Yang 已提交
15
    :return:
Y
Yu Yang 已提交
16
    """
Q
qiaolongfei 已提交
17 18
    for layer in layers:
        if not isinstance(layer, v2_layer.Layer):
Y
Yu Yang 已提交
19
            raise ValueError(
Q
qiaolongfei 已提交
20 21 22 23 24
                'create must pass a topologies which type is paddle.layer.Layer')
    model_config = v2_layer.parse_network(*layers)
    pool = Parameters()
    for param in model_config.parameters:
        pool.__append_config__(param)
Y
Yu Yang 已提交
25
    return pool
Y
Yu Yang 已提交
26 27


Y
Yu Yang 已提交
28
class Parameters(object):
Y
Yu Yang 已提交
29
    """
Y
Yu Yang 已提交
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
    Parameters is a dictionary contains Paddle's parameter. The key of
    Parameters is the name of parameter. The value of Parameters is a plain
    :code:`numpy.ndarry` .

    Basically usage is

    ..  code-block:: python

        data = paddle.layers.data(...)
        ...
        out = paddle.layers.fc(...)

        parameters = paddle.parameters.create(out)

        parameter_names = parameters.names()
        fc_mat = parameters.get('fc')
        print fc_mat
Y
Yu Yang 已提交
47 48
    """

Y
Yu Yang 已提交
49
    def __init__(self):
Y
Yu Yang 已提交
50 51 52 53
        self.__param_conf__ = dict()
        self.__gradient_machines__ = []
        self.__tmp_params__ = []

Y
Yu Yang 已提交
54 55 56 57 58 59 60 61 62 63
    def __append_config__(self, param_conf):
        """
        Append a parameter configuration. It used to initialize Parameters and
        should be invoked only in paddle.parameters.create

        :param param_conf: The parameter configuration in protobuf
        :type param_conf: ParameterConfig
        :return: Nothing
        """

Y
Yu Yang 已提交
64 65 66 67 68 69 70 71 72
        if not isinstance(param_conf, ParameterConfig):
            raise ValueError("param_conf must be paddle.proto.ParameterConfig")

        if param_conf.name in self.__param_conf__:
            raise ValueError("duplicated parameter %s" % param_conf.name)

        self.__param_conf__[param_conf.name] = param_conf

    def keys(self):
Y
Yu Yang 已提交
73 74 75 76 77
        """
        keys are the names of each parameter.
        :return: list of parameter name
        :rtype: list
        """
Y
Yu Yang 已提交
78 79 80
        return self.__param_conf__.keys()

    def names(self):
Y
Yu Yang 已提交
81 82 83 84 85
        """
        names of each parameter.
        :return: list of parameter name
        :rtype: list
        """
Y
Yu Yang 已提交
86 87 88
        return self.keys()

    def has_key(self, key):
Y
Yu Yang 已提交
89 90 91 92 93 94
        """
        has_key return true if there are such parameter name == key
        :param key: Parameter name
        :type key: basestring
        :return: True if contains such key
        """
Y
Yu Yang 已提交
95 96
        return key in self.__param_conf__.keys()

Y
Yu Yang 已提交
97
    def __iter__(self):
Y
Yu Yang 已提交
98 99 100 101 102 103 104 105 106 107 108 109
        """
        Return an iterator of parameter name. It is used by `for loop`
        or `in` operator.

        ..  code-block:: python

            parameters = paddle.parameters.create(...)
            if "fc_param" in parameters:
                print 'OK'
        :return: an iterator of parameter name
        :rtype: iterator
        """
Y
Yu Yang 已提交
110 111
        return iter(self.__param_conf__)

Y
Yu Yang 已提交
112
    def __getitem__(self, key):
Y
Yu Yang 已提交
113 114 115 116 117 118 119 120 121
        """
        Get parameter by parameter name. It uses Python dict syntax.

        :note: It will always copy the parameter from C++ side.
        :param key: Parameter name
        :type key: basestring
        :return: parameter value
        :rtype: np.ndarray
        """
Y
Yu Yang 已提交
122 123 124 125 126 127 128 129 130 131 132 133 134
        shape = self.get_shape(key)

        if len(self.__gradient_machines__) == 0:
            # create new parameter in python numpy.
            return np.ndarray(shape=shape, dtype=np.float32)
        else:
            for each_gradient_machine in self.__gradient_machines__:
                param = __get_parameter_in_gradient_machine__(
                    each_gradient_machine, key)
                # for simplify implementation now, we always copy from C++
                assert isinstance(param, api.Parameter)
                val = param.getBuf(api.PARAMETER_VALUE)
                assert isinstance(val, api.Vector)
Y
Yu Yang 已提交
135 136
                val = val.copyToNumpyArray()
                return val
Y
Yu Yang 已提交
137 138 139 140 141
                # else continue

            raise RuntimeError("Unexpected branch")

    def get_shape(self, key):
Y
Yu Yang 已提交
142 143 144 145 146 147 148
        """
        get shape of the parameter.
        :param key: parameter name
        :type key: basestring
        :return: parameter's shape
        :rtype: tuple
        """
Y
Yu Yang 已提交
149 150 151 152 153
        if not isinstance(key, basestring):
            raise ValueError("parameter name should be string")
        if not self.has_key(key):
            raise ValueError("No such parameter %s" % key)
        conf = self.__param_conf__[key]
Y
Yu Yang 已提交
154
        return tuple(map(int, conf.dims))
Y
Yu Yang 已提交
155 156

    def __setitem__(self, key, value):
Y
Yu Yang 已提交
157 158 159 160 161 162 163 164 165 166 167
        """
        Set parameter by parameter name & value. It use Python dict syntax.

        :note: It will always copy the parameter to C++ side.
        :param key: Parameter name
        :type key: basestring
        :param value: Parameter matrix.
        :type value: np.ndarray
        :return: Nothing
        """

Y
Yu Yang 已提交
168 169 170 171
        if not isinstance(value, np.ndarray):
            raise ValueError("Must return ndarray")
        value = value.astype(dtype=np.float32)
        shape = self.get_shape(key)
Y
Yu Yang 已提交
172
        if value.shape != shape:
Y
Yu Yang 已提交
173 174 175 176 177 178 179 180 181 182
            raise ValueError("Value shape mismatch, expect %s, should %s" %
                             (shape, value.shape))

        if len(self.__gradient_machines__) == 0:
            self.__tmp_params__.append((key, value))
        else:
            for each_gradient_machine in self.__gradient_machines__:
                __copy_parameter_to_gradient_machine__(each_gradient_machine,
                                                       key, value)

Y
Yu Yang 已提交
183
    def get(self, parameter_name):
Y
Yu Yang 已提交
184 185 186 187 188 189 190 191 192
        """
        Get parameter by parameter name.

        :note: It will always copy the parameter from C++ side.
        :param parameter_name: parameter name
        :type parameter_name: basestring
        :return: The parameter matrix.
        :rtype: np.ndarray
        """
Y
Yu Yang 已提交
193 194 195
        return self.__getitem__(key=parameter_name)

    def set(self, parameter_name, value):
Y
Yu Yang 已提交
196 197 198 199 200 201 202 203
        """
        Set parameter by parameter name & matrix.
        :param parameter_name: parameter name
        :type parameter_name: basestring
        :param value: parameter matrix
        :type value: np.ndarray
        :return: Nothing.
        """
Y
Yu Yang 已提交
204 205
        self.__setitem__(key=parameter_name, value=value)

Y
Yu Yang 已提交
206
    def append_gradient_machine(self, gradient_machine):
Y
Yu Yang 已提交
207 208 209 210 211 212 213 214 215
        """
        append gradient machine to parameters. This method is used internally in
        Trainer.train.

        :param gradient_machine: Paddle C++ GradientMachine object.
        :type gradient_machine: api.GradientMachine
        :return:
        """

Y
Yu Yang 已提交
216 217 218 219 220 221 222 223 224 225 226
        if not isinstance(gradient_machine, api.GradientMachine):
            raise ValueError("gradient_machine should be api.GradientMachine")

        if len(self.__tmp_params__) != 0:
            for name, val in self.__tmp_params__:
                try:
                    __copy_parameter_to_gradient_machine__(gradient_machine,
                                                           name, val)
                except ValueError:
                    # If no such parameter in gradient machine, then don't copy
                    pass
227 228

        self.__gradient_machines__.append(gradient_machine)
Y
Yu Yang 已提交
229 230 231 232


def __get_parameter_in_gradient_machine__(gradient_machine, name):
    """
Y
Yu Yang 已提交
233

Y
Yu Yang 已提交
234 235 236 237 238 239 240 241
    :param gradient_machine:
    :type gradient_machine: api.GradientMachine
    :param name:
    :return:
    :rtype: api.Parameter
    """
    params = filter(lambda p: p.getName() == name,
                    gradient_machine.getParameters())
Y
Yu Yang 已提交
242

Y
Yu Yang 已提交
243 244 245 246 247 248
    if len(params) == 0:
        raise ValueError("No such parameter")
    elif len(params) > 1:
        raise ValueError("Unexpected branch")
    else:
        return params[0]
Y
Yu Yang 已提交
249 250


Y
Yu Yang 已提交
251
def __copy_parameter_to_gradient_machine__(gradient_machine, name, arr):
Y
Yu Yang 已提交
252
    """
Y
Yu Yang 已提交
253
    Copy a python ndarray into the gradient machine.
Y
Yu Yang 已提交
254

Y
Yu Yang 已提交
255 256 257 258 259
    :param gradient_machine:
    :type gradient_machine: api.GradientMachine
    :param name:
    :param arr:
    :type arr: np.ndarray
Y
Yu Yang 已提交
260
    :return:
Y
Yu Yang 已提交
261
    :rtype: api.Parameter
Y
Yu Yang 已提交
262
    """
Y
Yu Yang 已提交
263 264 265 266
    param = __get_parameter_in_gradient_machine__(gradient_machine, name)
    vec = param.getBuf(api.PARAMETER_VALUE)
    assert isinstance(vec, api.Vector)
    vec.copyFromNumpyArray(arr.flatten())