FilesExpand file tree

 master

/

array_ops.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

110 lines (84 loc) · 4.23 KB

 master

/

array_ops.py

Copy path

Top

File metadata and controls

• Code
• Blame

110 lines (84 loc) · 4.23 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

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

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

#! /usr/bin/python

# -*- coding: utf-8 -*-

"""A file containing functions related to array manipulation."""

from tensorflow.python.eager import context

from tensorflow.python.framework import constant_op, dtypes, ops, tensor_shape

from tensorflow.python.framework.constant_op import constant

from tensorflow.python.framework.ops import convert_to_tensor

from tensorflow.python.ops.array_ops import shape_internal

from tensorflow.python.ops.gen_array_ops import fill, reshape

__all__ = ['alphas', 'alphas_like']

def alphas(shape, alpha_value, name=None):

"""Creates a tensor with all elements set to `alpha_value`.

This operation returns a tensor of type `dtype` with shape `shape` and all

elements set to alpha.

Parameters

----------

shape: A list of integers, a tuple of integers, or a 1-D `Tensor` of type `int32`.

The shape of the desired tensor

alpha_value: `float32`, `float64`, `int8`, `uint8`, `int16`, `uint16`, int32`, `int64`

The value used to fill the resulting `Tensor`.

name: str

A name for the operation (optional).

Returns

-------

A `Tensor` with all elements set to alpha.

Examples

--------

>>> tl.alphas([2, 3], tf.int32) # [[alpha, alpha, alpha], [alpha, alpha, alpha]]

"""

with ops.name_scope(name, "alphas", [shape]) as name:

alpha_tensor = convert_to_tensor(alpha_value)

alpha_dtype = dtypes.as_dtype(alpha_tensor.dtype).base_dtype

if not isinstance(shape, ops.Tensor):

try:

shape = constant_op._tensor_shape_tensor_conversion_function(tensor_shape.TensorShape(shape))

except (TypeError, ValueError):

shape = ops.convert_to_tensor(shape, dtype=dtypes.int32)

if not shape._shape_tuple():

shape = reshape(shape, [-1]) # Ensure it's a vector

try:

output = constant(alpha_value, shape=shape, dtype=alpha_dtype, name=name)

except (TypeError, ValueError):

output = fill(shape, constant(alpha_value, dtype=alpha_dtype), name=name)

if output.dtype.base_dtype != alpha_dtype:

raise AssertionError("Dtypes do not corresponds: %s and %s" % (output.dtype.base_dtype, alpha_dtype))

return output

def alphas_like(tensor, alpha_value, name=None, optimize=True):

"""Creates a tensor with all elements set to `alpha_value`.

Given a single tensor (`tensor`), this operation returns a tensor of the same

type and shape as `tensor` with all elements set to `alpha_value`.

Parameters

----------

tensor: tf.Tensor

The Tensorflow Tensor that will be used as a template.

alpha_value: `float32`, `float64`, `int8`, `uint8`, `int16`, `uint16`, int32`, `int64`

The value used to fill the resulting `Tensor`.

name: str

A name for the operation (optional).

optimize: bool

if true, attempt to statically determine the shape of 'tensor' and encode it as a constant.

Returns

-------

A `Tensor` with all elements set to `alpha_value`.

Examples

--------

>>> tensor = tf.constant([[1, 2, 3], [4, 5, 6]])

>>> tl.alphas_like(tensor, 0.5) # [[0.5, 0.5, 0.5], [0.5, 0.5, 0.5]]

"""

with ops.name_scope(name, "alphas_like", [tensor]) as name:

tensor = ops.convert_to_tensor(tensor, name="tensor")

if context.in_eager_mode(): # and dtype is not None and dtype != tensor.dtype:

ret = alphas(shape_internal(tensor, optimize=optimize), alpha_value=alpha_value, name=name)

else: # if context.in_graph_mode():

# For now, variant types must be created via zeros_like; as we need to

# pass the input variant object to the proper zeros callback.

if (optimize and tensor.shape.is_fully_defined()):

# We can produce a zeros tensor independent of the value of 'tensor',

# since the shape is known statically.

ret = alphas(tensor.shape, alpha_value=alpha_value, name=name)

# elif dtype is not None and dtype != tensor.dtype and dtype != dtypes.variant:

else:

ret = alphas(shape_internal(tensor, optimize=optimize), alpha_value=alpha_value, name=name)

ret.set_shape(tensor.get_shape())

return ret