tensor.py 9.3 KB
Newer Older
Y
Yu Yang 已提交
1
from ..layer_helper import LayerHelper
2
from ..param_attr import ParamAttr
X
xuwei06 已提交
3 4 5 6
from ..framework import convert_np_dtype_to_dtype_
from ..framework import Variable
from ..core import DataType
import numpy
Y
Yu Yang 已提交
7 8

__all__ = [
9 10 11 12 13 14 15 16 17 18
    'create_tensor',
    'create_parameter',
    'cast',
    'concat',
    'sums',
    'assign',
    'fill_constant_batch_size_like',
    'fill_constant',
    'ones',
    'zeros',
Y
Yu Yang 已提交
19 20 21
]


22
def create_tensor(dtype, name=None):
Y
Yu Yang 已提交
23 24 25 26
    helper = LayerHelper("create_tensor", **locals())
    return helper.create_variable(name=helper.name, dtype=dtype)


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
def create_parameter(shape,
                     dtype,
                     attr=None,
                     is_bias=False,
                     default_initializer=None):
    """
    Create a parameter
    Args:
        shape(list[int]): shape of the parameter
        dtype(string): element type of the parameter
        attr(ParamAttr): attributes of the parameter
        is_bias(bool): This can affect which default initializer is chosen
                       when default_initializer is None. If is_bias,
                       initializer.Constant(0.0) will be used. Otherwise,
                       Xavier() will be used.
        default_initializer(Initializer): initializer for the parameter

    Returns:
        Parameter: the created parameter
    """
    helper = LayerHelper("create_parameter")
    if attr is None:
        attr = ParamAttr()
    return helper.create_parameter(attr, shape, dtype, is_bias,
                                   default_initializer)


54
def cast(x, dtype):
Y
Yu Yang 已提交
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
    """
    This function takes in the input with input_dtype
    and casts it to the output_dtype as the output.
    """
    helper = LayerHelper('cast', **locals())
    out = helper.create_tmp_variable(dtype=dtype)
    helper.append_op(
        type='cast',
        inputs={'X': [x]},
        outputs={'Out': [out]},
        attrs={'in_dtype': x.dtype,
               'out_dtype': out.dtype})
    return out


70
def concat(input, axis=0):
Y
Yu Yang 已提交
71
    """
72 73 74
    **Concat**

    This function concatenates the input along the axis mentioned
Y
Yu Yang 已提交
75
    and returns that as the output.
76 77 78 79 80 81 82 83 84 85 86

    Args:
        input(list): List of tensors to be concatenated
        axis(int): Integer axis along which the tensors will be concatenated

    Returns:
        Variable: Output variable of the concatenation

    Examples:
        .. code-block:: python
          out = fluid.layers.concat(input=[Efirst, Esecond, Ethird, Efourth])
Y
Yu Yang 已提交
87 88 89 90 91 92 93 94 95 96 97
    """
    helper = LayerHelper('concat', **locals())
    out = helper.create_tmp_variable(dtype=helper.input_dtype())
    helper.append_op(
        type='concat',
        inputs={'X': input},
        outputs={'Out': [out]},
        attrs={'axis': axis})
    return out


98
def sums(input, out=None):
K
kavyasrinet 已提交
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
    """This function performs the sum operation on the input and returns the
    result as the output.

    Args:
        input (Variable|list): The input tensor that has the elements
                               that need to be summed up.

    Returns:
        Variable: The tensor type variable that has the sum of input
                  written to it.

    Examples:
        .. code-block::python

          tmp = fluid.layers.zeros(shape=[10], dtype='int32')
          i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
          a0 = layers.array_read(array=tmp, i=i)
          i = layers.increment(x=i)
          a1 = layers.array_read(array=tmp, i=i)
          mean_a0 = layers.mean(x=a0)
          mean_a1 = layers.mean(x=a1)
          a_sum = layers.sums(input=[mean_a0, mean_a1])
Y
Yu Yang 已提交
121 122 123 124 125 126 127 128
    """
    helper = LayerHelper('sum', **locals())
    if out is None:
        out = helper.create_tmp_variable(dtype=helper.input_dtype())
    helper.append_op(type='sum', inputs={'X': input}, outputs={'Out': out})
    return out


129
def assign(input, output):
130 131 132 133 134 135
    """
    **Assign**

    This function copies the *input* Variable to the *output* Variable.

    Args:
X
xuwei06 已提交
136
        input(Variable|numpy.ndarray): The source variable
137 138 139 140 141 142 143 144 145 146 147
        output(Variable): The destination variable

    Returns:
        Variable: The destination variable that was supplied as the *output*.

    Examples:
        .. code-block:: python
          out = fluid.layers.create_tensor(dtype='float32')
          hidden = fluid.layers.fc(input=data, size=10)
          fluid.layers.assign(hidden, out)
    """
Y
Yu Yang 已提交
148
    helper = LayerHelper('assign', **locals())
X
xuwei06 已提交
149 150 151 152 153 154 155 156 157 158
    if isinstance(input, Variable):
        helper.append_op(
            type='scale',
            inputs={'X': [input]},
            outputs={'Out': [output]},
            attrs={'scale': 1.0})
    elif isinstance(input, numpy.ndarray):
        dtype = convert_np_dtype_to_dtype_(input.dtype)
        if dtype == DataType.FP32:
            value_name = "fp32_values"
159
            values = [float(v) for v in input.flat]
X
xuwei06 已提交
160 161
        elif dtype == DataType.INT32:
            value_name = "int32_values"
162
            values = [int(v) for v in input.flat]
X
xuwei06 已提交
163 164
        else:
            raise ValueError("Unsupported dtype %s", input.dtype)
165 166 167
        if input.size > 1024 * 1024:
            raise ValueError("The size of input is too big. Please consider "
                             "saving it to file and 'load_op' to load it")
X
xuwei06 已提交
168 169 170 171 172 173 174

        helper.append_op(
            type='assign_value',
            outputs={'Out': [output]},
            attrs={
                'dtype': dtype,
                'shape': list(input.shape),
175
                value_name: values
X
xuwei06 已提交
176 177 178 179
            })
    else:
        raise ValueError("Wrong type for assign input: %s" % type(input))

Y
Yu Yang 已提交
180 181 182
    return output


183
def fill_constant(shape, dtype, value, out=None):
Y
Yu Yang 已提交
184
    """
185 186
    **fill_constant**

187 188
    This function creates a tensor with specified `shape` and `dtype`, and
    initializes it with a constant specifed by `value`.
K
kavyasrinet 已提交
189

190
    The attribute `stop_gradient` of the created tensor is set to True.
191 192

    Args:
193 194 195 196
        shape(tuple|list|None): Shape of the output tensor.
        dtype(np.dtype|core.DataType|str): Data type of the output tensor.
        value(float): The constant value used to initialize the output tensor.
        out(Variable): The output tensor.
197 198

    Returns:
199
        Variable: The tensor variable storing the output.
200 201 202 203 204

    Examples:
        .. code-block:: python

          data = fluid.layers.fill_constant(shape=[1], value=0, dtype='int64')
Y
Yu Yang 已提交
205
    """
206

Y
Yu Yang 已提交
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
    helper = LayerHelper("fill_constant", **locals())
    if out is None:
        out = helper.create_tmp_variable(dtype=dtype)
    helper.append_op(
        type='fill_constant',
        inputs={},
        outputs={'Out': [out]},
        attrs={'shape': shape,
               'dtype': out.dtype,
               'value': float(value)})
    out.stop_gradient = True
    return out


def fill_constant_batch_size_like(input,
                                  shape,
                                  dtype,
                                  value,
                                  input_dim_idx=0,
226
                                  output_dim_idx=0):
227 228 229
    """
    **fill_constant_batch_size_like**

K
kavyasrinet 已提交
230 231 232
    This function creates a tensor of specified *shape*, *dtype* and batch size,
    and initializes this with a constant supplied in *value*. The batch size is
    obtained from the `input` tensor.
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249

    It also sets *stop_gradient* to True.

    Args:
        input(Variable): Tensor whose dimensions will be used to get batch size
        shape(tuple|list|None): Shape of output tensor
        dtype(np.dtype|core.DataType|str): Data type of output tensor
        value(float): Constant value to initialize the output tensor
        input_dim_idx(int): Index of input's batch size dimension
        output_dim_idx(int): Index of output's batch size dimension

    Returns:
        Variable: The tensor variable storing the output

    Examples:
        .. code-block:: python

250 251
          data = fluid.layers.fill_constant_batch_size_like(
              input=like, shape=[1], value=0, dtype='int64')
252
    """
Y
Yu Yang 已提交
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
    helper = LayerHelper("fill_constant_batch_size_like", **locals())
    out = helper.create_tmp_variable(dtype=dtype)
    helper.append_op(
        type='fill_constant_batch_size_like',
        inputs={'Input': input},
        outputs={'Out': [out]},
        attrs={
            'shape': shape,
            'dtype': out.dtype,
            'value': float(value),
            'input_dim_idx': input_dim_idx,
            'output_dim_idx': output_dim_idx
        })
    out.stop_gradient = True
    return out


270
def ones(shape, dtype):
Y
Yu Yang 已提交
271
    """
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
    **ones**

    This function creates a tensor of specified *shape* and
    *dtype*, and initializes this with 1.

    It also sets *stop_gradient* to True.

    Args:
        shape(tuple|list|None): Shape of output tensor
        dtype(np.dtype|core.DataType|str): Data type of output tensor

    Returns:
        Variable: The tensor variable storing the output

    Examples:
        .. code-block:: python

          data = fluid.layers.ones(shape=[1], dtype='int64')
Y
Yu Yang 已提交
290 291 292 293
    """
    return fill_constant(value=1.0, **locals())


294
def zeros(shape, dtype):
Y
Yu Yang 已提交
295
    """
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
    **zeros**

    This function creates a tensor of specified *shape* and
    *dtype*, and initializes this with 0.

    It also sets *stop_gradient* to True.

    Args:
        shape(tuple|list|None): Shape of output tensor
        dtype(np.dtype|core.DataType|str): Data type of output tensor

    Returns:
        Variable: The tensor variable storing the output

    Examples:
        .. code-block:: python

          data = fluid.layers.zeros(shape=[1], dtype='int64')
Y
Yu Yang 已提交
314 315
    """
    return fill_constant(value=0.0, **locals())