• tf.Variable

    参考 tf.Variable - 云+社区 - 腾讯云

    目录

    __init__

    __abs__

    __add__

    __getitem__

    __gt__

    __invert__

    __iter__

    __le__

    __lt__

    __matmul__

    __mod__

    __mul__

    __ne__

    __neg__

    __or__

    __pow__

    __radd__

    __rand__

    __rdiv__

    __rfloordiv__

    __rmatmul__

    __rmod__

    __rmul__

    __ror__

    __rpow__

    __rsub__

    __rtruediv__

    __rxor__

    assign

    assign_add

    assign_sub

    batch_scatter_update

    count_up_to

    eval

    experimental_ref

    from_proto

    gather_nd

    get_shape

    initialized_value

    load

    read_value

    scatter_add

    scatter_div

    scatter_max

    scatter_min

    scatter_mul

    scatter_nd_add

    scatter_nd_sub

    scatter_nd_update

    scatter_sub

    scatter_update

    set_shape

    sparse_read

    to_proto

    value

    变量跨run()调用在图中维护状态。通过构造类变量的实例，可以向图中添加一个变量。Variable()构造函数需要变量的初值，它可以是任何类型和形状的张量。初值定义变量的类型和形状。构造完成后，变量的类型和形状是固定的。可以使用指定方法之一更改值。如果稍后要更改变量的形状，必须使用带有validate_shape=False的赋值Op。与任何张量一样，使用Variable()创建的变量可以用作图中其他Ops的输入。此外，张量类的所有重载运算符都被传递到变量上，因此您也可以通过对变量进行算术将节点添加到图中。

    1. import tensorflow as tf
    2.  
    3. # Create a variable.
    4. w = tf.Variable(, name=)
    5.  
    6. # Use the variable in the graph like any Tensor.
    7. y = tf.matmul(w, ...another variable or tensor...)
    8.  
    9. # The overloaded operators are available too.
    10. z = tf.sigmoid(w + y)
    11.  
    12. # Assign a new value to the variable with `assign()` or a related method.
    13. w.assign(w + 1.0)
    14. w.assign_add(1.0)

    启动图形时，必须显式初始化变量，然后才能运行使用其值的操作系统。你可以通过运行变量的初始化器op、从保存文件中还原变量，或者简单地运行赋值op来初始化变量。事实上，变量初始化器op只是一个赋值op，它将变量的初值赋给变量本身。

    1. # Launch the graph in a session.
    2. with tf.compat.v1.Session() as sess:
    3.     # Run the variable initializer.
    4.     sess.run(w.initializer)
    5.     # ...you now can run ops that use the value of 'w'...

    最常见的初始化模式是使用方便的函数global_variables_initializer()将Op添加到初始化所有变量的图中。然后在启动图表之后运行该Op。

    1. # Add an Op to initialize global variables.
    2. init_op = tf.compat.v1.global_variables_initializer()
    3.  
    4. # Launch the graph in a session.
    5. with tf.compat.v1.Session() as sess:
    6.     # Run the Op that initializes global variables.
    7.     sess.run(init_op)
    8.     # ...you can now run any Op that uses variable values...

    如果需要创建一个初始值依赖于另一个变量的变量，请使用另一个变量的initialized_value()。这确保变量以正确的顺序初始化。所有变量都自动收集到创建它们的图中。默认情况下，构造函数将新变量添加到graph collection GraphKeys.GLOBAL_VARIABLES。函数global_variables()返回集合的内容。在构建机器学习模型时，通常可以方便地区分包含可训练模型参数的变量和其他变量，例如用于计算训练步骤的全局步骤变量。为了简化这一点，变量构造函数支持一个可训练的=参数。如果为真，则新变量也将添加到graph collection GraphKeys.TRAINABLE_VARIABLES中。函数trainable_variables()返回这个集合的内容。各种优化器类都使用这个集合作为要优化的默认变量列表。

    __init__

    1. __init__(
    2.     initial_value=None,
    3.     trainable=None,
    4.     validate_shape=True,
    5.     caching_device=None,
    6.     name=None,
    7.     variable_def=None,
    8.     dtype=None,
    9.     import_scope=None,
    10.     constraint=None,
    11.     synchronization=tf.VariableSynchronization.AUTO,
    12.     aggregation=tf.compat.v1.VariableAggregation.NONE,
    13.     shape=None
    14. )

    创建一个值为initial_value的新变量。新变量被添加到集合中列出的图形集合中，集合默认为[GraphKeys.GLOBAL_VARIABLES]。如果trainable为真，则该变量还将添加到graph collection GraphKeys.TRAINABLE_VARIABLES中。这个构造函数创建一个变量Op和一个赋值Op来将变量设置为其初始值。

    参数：

    • initial_value:张量，或可转换为张量的Python对象，它是变量的初值。初始值必须指定一个形状，除非validate_shape被设置为False。也可以是可调用的，没有参数，调用时返回初始值。在这种情况下，必须指定dtype。(注意，在这里使用初始化器函数之前，必须先将init_ops.py中的初始化器函数绑定到一个形状。)
    • 可训练的:如果是真的，gradient tape会自动监视这个变量的使用。默认值为True，除非同步设置为ON_READ，在这种情况下，同步设置为False。
    • validate_shape:如果为False，则允许用一个未知形状的值初始化变量。如果为真，默认情况下，initial_value的形状必须是已知的。
    • caching_device:可选的设备字符串，描述变量应该缓存到什么地方以便读取。变量的设备的默认值。如果没有，则缓存到另一个设备上。典型的用途是在使用该变量的操作系统所在的设备上缓存，通过Switch和其他条件语句来重复复制。
    • name:变量的可选名称。默认值为“Variable”，并自动进行uniquified。
    • VariableDef协议缓冲区。如果没有，则使用其内容重新创建变量对象，并引用图中必须已经存在的变量节点。图形没有改变。variable_def和其他参数是互斥的。
    • dtype:如果设置了，initial_value将转换为给定的类型。如果没有，要么保留数据类型(如果initial_value是一个张量)，要么由convert_to_张量决定。
    • import_scope:可选的字符串。要添加到变量的名称范围。仅在从协议缓冲区初始化时使用。
    • constraint:优化器更新后应用于变量的可选投影函数(例如，用于为层权重实现规范约束或值约束)。函数必须将表示变量值的未投影张量作为输入，并返回投影值的张量(其形状必须相同)。在进行异步分布式培训时使用约束并不安全。
    • synchronization:指示何时聚合分布式变量。可接受的值是在tf.VariableSynchronization类中定义的常量。默认情况下，同步设置为AUTO，当前分发策略选择何时同步。
    • aggregation:指示如何聚合分布式变量。可接受的值是在tf.VariableAggregation类中定义的常量。
    • shape:(可选)这个变量的形状。如果没有，则使用initial_value的形状。当将这个参数设置为tf.TensorShape(None)(表示一个未指定的形状)时，可以用不同形状的值为变量赋值。

    可能产生的异常：

    • ValueError: If both variable_def and initial_value are specified.
    • ValueError: If the initial value is not specified, or does not have a shape and validate_shape is True.
    • RuntimeError: If eager execution is enabled.

    __abs__

    1. __abs__(
    2.     x,
    3.     name=None
    4. )

    计算张量的绝对值。给定一个整数或浮点值的张量，这个操作返回一个相同类型的张量，其中每个元素都包含输入中相应元素的绝对值。给定一个复数张量x，这个操作返回一个类型为float32或float64的张量，这是x中每个元素的绝对值。x中所有的元素必须是复数形式a+bj，绝对值为a2+b2" role="presentation" style="position: relative;">a2+b2。例如:

    1. x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]])
    2. tf.abs(x)  # [5.25594902, 6.60492229]

    参数：

    • x:一个类型为float16、float32、float64、int32、int64、complex64或complex128的张量或稀疏张量。
    • name:操作的名称(可选)。

    返回值：

    • 一个张量或稀疏张量，其大小、类型和稀疏性与x的绝对值相同。注意，对于complex64或complex128输入，返回的张量类型分别为float32或float64。

    __add__

    1. __and__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    返回x和y元素的真值。

    参数：

    • x: bool型张量。
    • y: bool型张量。
    • name:操作的名称(可选)。

    返回值：

    • 布尔类型的张量。

    __getitem__

    1. __getitem__(
    2.     var,
    3.     slice_spec
    4. )

    创建给定变量的切片助手对象。这允许从变量当前内容的一部分创建子张量。看到tf.Tensor。获取切片的详细示例。此外，该函数还允许对切片范围赋值。这类似于Python中的_setitem__功能。但是，语法不同，因此用户可以捕获赋值操作，以便分组或传递给ssh .run()。例如,

    1. import tensorflow as tf
    2. A = tf.Variable([[1,2,3], [4,5,6], [7,8,9]], dtype=tf.float32)
    3. with tf.compat.v1.Session() as sess:
    4.   sess.run(tf.compat.v1.global_variables_initializer())
    5.   print(sess.run(A[:2, :2]))  # => [[1,2], [4,5]]
    6.  
    7.   op = A[:2,:2].assign(22. * tf.ones((2, 2)))
    8.   print(sess.run(op))  # => [[22, 22, 3], [22, 22, 6], [7,8,9]]

    注意，当前的赋值不支持NumPy广播语义。

    参数：

    • var: ops.Variable对象
    • slice_spec: Tensor.getitem的参数。

    返回值：

    • 张量的适当切片，基于slice_spec。作为一个操作符。操作符还有一个assign()方法，可用于生成赋值操作符。

    可能产生的异常：

    • ValueError: If a slice range is negative size.
    • TypeError: TypeError: If the slice indices aren't int, slice, ellipsis, tf.newaxis or int32/int64 tensors.

    __gt__

    1. __gt__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    返回元素(x > y)的真值。

    参数：

    • x:张量。必须是下列类型之一:float32、float64、int32、uint8、int16、int8、int64、bfloat16、uint16、half、uint32、uint64。
    • y:张量。必须具有与x相同的类型。
    • name:操作的名称(可选)。

    返回值：

    • 布尔类型的张量。

    __invert__

    1. __invert__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    返回NOT x element-wise的真值。

    参数：

    • x: bool型张量。
    • name:操作的名称(可选)。

    返回值：

    • 布尔类型的张量。

    __iter__

    __iter__()

    防止迭代的哑方法。不要打电话。注意(mrry):如果我们将getitem注册为一个重载操作符，Python将勇敢地尝试迭代变量的张量，从0到无穷。声明此方法可防止此意外行为。

    可能产生的异常：

    • TypeError: when invoked.

    __le__

    1. __le__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    返回元素的真值(x <= y)。注意:数学。less_equal支持广播。更多关于广播

    参数：

    • x:张量。必须是下列类型之一:float32、float64、int32、uint8、int16、int8、int64、bfloat16、uint16、half、uint32、uint64。
    • y:张量。必须具有与x相同的类型。
    • name:操作的名称(可选)。

    返回值：

    • 布尔类型的张量。

    __lt__

    1. __lt__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    返回(x < y)元素的真值。注意:math.less不支持广播。

    参数：

    • x:张量。必须是下列类型之一:float32、float64、int32、uint8、int16、int8、int64、bfloat16、uint16、half、uint32、uint64。
    • y:张量。必须具有与x相同的类型。
    • name:操作的名称(可选)。

    返回值：

    • 布尔类型的张量。

    __matmul__

    1. __matmul__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    将矩阵a乘以矩阵b，得到a * b。在任何换位之后，输入必须是秩为>= 2的张量，其中内部2维指定有效的矩阵乘法参数，并且任何进一步的外部维度匹配。两个矩阵必须是同一类型的。支持的类型有:float16、float32、float64、int32、complex64、complex128。通过将相应的标志之一设置为True，可以动态地对矩阵进行换位或附加(共轭和换位)。这些默认为False。如果其中一个或两个矩阵包含很多0，则可以通过将相应的a_is_sparse或b_is_稀疏标志设置为True来使用更有效的乘法算法。这些默认为False。这种优化只适用于数据类型为bfloat16或float32的普通矩阵(秩为2的张量)。

    例如：

    1. # 2-D tensor `a`
    2. # [[1, 2, 3],
    3. #  [4, 5, 6]]
    4. a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])
    5.  
    6. # 2-D tensor `b`
    7. # [[ 7,  8],
    8. #  [ 9, 10],
    9. #  [11, 12]]
    10. b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])
    11.  
    12. # `a` * `b`
    13. # [[ 58,  64],
    14. #  [139, 154]]
    15. c = tf.matmul(a, b)
    16.  
    17.  
    18. # 3-D tensor `a`
    19. # [[[ 1,  2,  3],
    20. #   [ 4,  5,  6]],
    21. #  [[ 7,  8,  9],
    22. #   [10, 11, 12]]]
    23. a = tf.constant(np.arange(1, 13, dtype=np.int32),
    24.                 shape=[2, 2, 3])
    25.  
    26. # 3-D tensor `b`
    27. # [[[13, 14],
    28. #   [15, 16],
    29. #   [17, 18]],
    30. #  [[19, 20],
    31. #   [21, 22],
    32. #   [23, 24]]]
    33. b = tf.constant(np.arange(13, 25, dtype=np.int32),
    34.                 shape=[2, 3, 2])
    35.  
    36. # `a` * `b`
    37. # [[[ 94, 100],
    38. #   [229, 244]],
    39. #  [[508, 532],
    40. #   [697, 730]]]
    41. c = tf.matmul(a, b)
    42.  
    43. # Since python >= 3.5 the @ operator is supported (see PEP 465).
    44. # In TensorFlow, it simply calls the `tf.matmul()` function, so the
    45. # following lines are equivalent:
    46. d = a @ b @ [[10.], [11.]]
    47. d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])

    参数：

    • a:类型为float16、float32、float64、int32、complex64、complex128的张量，秩为> 1。
    • b:与a类型和秩相同的张量。
    • transpose_a:如果为真，则a在乘法之前转置。
    • transpose_a:如果为真，则b在乘法之前转置。
    • adjoint_a:如果是真的，a是共轭和转置之前的乘法。
    • adjoint_b:如果为真，b是共轭和转置之前的乘法。
    • a_is_疏:如果为真，则将a视为一个稀疏矩阵。
    • b_is_sparse:如果为真，则将b视为稀疏矩阵。
    • name:操作的名称(可选)。

    返回值：

    • 一个与A和b相同类型的张量，其中每个最内层的矩阵是A和b中相应矩阵的乘积，例如，如果所有转置或伴随属性都为假:对所有的指数，输出[..., i, j] = sum_k (a[..., i, k] * b[..., k, j])。注意:这是矩阵乘积，不是元素乘。

    可能产生的异常：

    • ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b are both set to True.

    __mod__

    1. __mod__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    返回除法的元素剩余部分。当x < 0 xor y < 0为真时，这符合Python语义，因为这里的结果与地板划分一致。例如，floor(x / y) * y + mod(x, y) = x。math.floormod支持广播。

    参数：

    • x:张量。必须是下列类型之一:int32、int64、bfloat16、half、float32、float64。
    • y:张量。必须具有与x相同的类型。
    • name:操作的名称(可选)。

    返回值：

    • 一个张量。与x类型相同。

    __mul__

    1. __mul__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    为“densedensity”和“DenseSparse”分派cwise mul。

    __ne__

    __ne__(other)

    逐元素比较两个变量是否相等。

    __neg__

    1. __neg__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    计算数值负值元素，也就是y=−x" role="presentation" style="position: relative;">y=−x。

    参数：

    • x：张量。必须是以下类型之一:bfloat16、half、float32、float64、int32、int64、complex64、complex128。
    • name：操作的名称(可选)。

    返回值：

    • 一个张量。与x类型相同。

    __or__

    1. __or__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    返回x或y元素的真值。注意:math.logical_or支持广播。

    参数：

    • x: bool型张量。
    • y: bool型张量。
    • name:操作的名称(可选)。

    返回：

    • bool类型的张量。

    __pow__

    1. __pow__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    计算一个值对另一个值的幂。给定一个张量x和一个张量y，这个操作计算x和y中对应的xy" role="presentation" style="position: relative;">xy。

    1. x = tf.constant([[2, 2], [3, 3]])
    2. y = tf.constant([[8, 16], [2, 3]])
    3. tf.pow(x, y)  # [[256, 65536], [9, 27]]

    参数：

    • x:类型为float16、float32、float64、int32、int64、complex64或complex128的张量。
    • y:类型为float16、float32、float64、int32、int64、complex64或complex128的张量。
    • name:操作的名称(可选)。

    返回值：

    • 一个张量。

    __radd__

    1. __radd__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    为字符串添加分派，为所有其他类型添加add_v2。

    __rand__

    1. __rand__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    返回x和y元素的真值。注意:math.logical_and支持广播。

    参数：

    • x: bool型张量。
    • y: bool型张量。
    • name:操作的名称(可选)。

    返回值：

    • 布尔类型的张量。

    __rdiv__

    1. __rdiv__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    使用Python 2语义划分两个值。用于Tensor.div。

    参数：

    • x:实数型张量分子。
    • y:实数型张量分母。
    • name:操作的名称(可选)。

    返回值：

    • x / y返回x和y的商。

    __rfloordiv__

    1. __rfloordiv__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    除以x / y元素，四舍五入到最负的整数。对于整数，与tf.compat.v1.div(x,y)相同，但是对于浮点参数，使用tf.floor(tf.compat.v1.div(x,y))，因此结果总是一个整数(尽管可能是一个用浮点表示的整数)。该op由python3中的x // y层划分和python2.7中的来自于future__导入划分生成。x和y必须具有相同的类型，并且结果也必须具有相同的类型。

    参数：

    • x:实数型张量分子。
    • y:实数型张量分母。
    • name:操作的名称(可选)。

    返回值：

    • x / y四舍五入。

    __rmatmul__

    1. __rmatmul__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    将矩阵a乘以矩阵b，得到a * b。在任何换位之后，输入必须是秩为>= 2的张量，其中内部2维指定有效的矩阵乘法参数，并且任何进一步的外部维度匹配。两个矩阵必须是同一类型的。支持的类型有:float16、float32、float64、int32、complex64、complex128。通过将相应的标志之一设置为True，可以动态地对矩阵进行换位或附加(共轭和换位)。这些默认为False。如果其中一个或两个矩阵包含很多0，则可以通过将相应的a_is_sparse或b_is_稀疏标志设置为True来使用更有效的乘法算法。这些默认为False。这种优化只适用于数据类型为bfloat16或float32的普通矩阵(秩为2的张量)。

    1. # 2-D tensor `a`
    2. # [[1, 2, 3],
    3. #  [4, 5, 6]]
    4. a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])
    5.  
    6. # 2-D tensor `b`
    7. # [[ 7,  8],
    8. #  [ 9, 10],
    9. #  [11, 12]]
    10. b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])
    11.  
    12. # `a` * `b`
    13. # [[ 58,  64],
    14. #  [139, 154]]
    15. c = tf.matmul(a, b)
    16.  
    17.  
    18. # 3-D tensor `a`
    19. # [[[ 1,  2,  3],
    20. #   [ 4,  5,  6]],
    21. #  [[ 7,  8,  9],
    22. #   [10, 11, 12]]]
    23. a = tf.constant(np.arange(1, 13, dtype=np.int32),
    24.                 shape=[2, 2, 3])
    25.  
    26. # 3-D tensor `b`
    27. # [[[13, 14],
    28. #   [15, 16],
    29. #   [17, 18]],
    30. #  [[19, 20],
    31. #   [21, 22],
    32. #   [23, 24]]]
    33. b = tf.constant(np.arange(13, 25, dtype=np.int32),
    34.                 shape=[2, 3, 2])
    35.  
    36. # `a` * `b`
    37. # [[[ 94, 100],
    38. #   [229, 244]],
    39. #  [[508, 532],
    40. #   [697, 730]]]
    41. c = tf.matmul(a, b)
    42.  
    43. # Since python >= 3.5 the @ operator is supported (see PEP 465).
    44. # In TensorFlow, it simply calls the `tf.matmul()` function, so the
    45. # following lines are equivalent:
    46. d = a @ b @ [[10.], [11.]]
    47. d = tf.matmul(tf.matmul(a, b), [[10.], [11.]])

    参数：

    • a:类型为float16、float32、float64、int32、complex64、complex128的张量，秩为> 1。
    • b:与a类型和秩相同的张量。
    • transpose_a:如果为真，则a在乘法之前转置。
    • transpose_b:如果为真，则b在乘法之前转置。
    • adjoint_a:如果是真的，a是共轭和转置之前的乘法。
    • adjoint_b:如果为真，b是共轭和转置之前的乘法。
    • a_is_疏:如果为真，则将a视为一个稀疏矩阵。
    • b_is_sparse:如果为真，则将b视为稀疏矩阵。
    • name:操作的名称(可选)。

    返回值：

    • 与A和b相同类型的张量，其中每个最内矩阵是A和b中相应矩阵的乘积，例如，如果所有转置或伴随属性都为假:输出[…， i, j] = sum_k (a[…， i, k] * b[…， k, j])，对于所有指标i, j。

    注意:这是矩阵乘积，不是元素乘积。

    可能产生的异常：

    • ValueError: If transpose_a and adjoint_a, or transpose_b and adjoint_b are both set to True.

    __rmod__

    1. __rmod__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    返回除法的元素剩余部分。当x < 0 xor y < 0为真时，这符合Python语义，因为这里的结果与地板划分一致。例如，floor(x / y) * y + mod(x, y) = x。floormod支持广播。更多关于广播

    参数：

    • x:张量。必须是下列类型之一:int32、int64、bfloat16、half、float32、float64。
    • y:张量。必须具有与x相同的类型。
    • name:操作的名称(可选)。

    返回值：

    • 一个张量。与x类型相同。

    __rmul__

    1. __rmul__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    为“densedensity”和“DenseSparse”分派cwise mul。

    __ror__

    1. __ror__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    返回x或y元素的真值。

    参数：

    • x: bool型张量。
    • y: bool型张量。
    • name:操作的名称(可选)。

    返回值：

    • bool类型的张量。

    __rpow__

    1. __rpow__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    计算一个值对另一个值的幂。给定一个张量x和一个张量y，这个操作计算x和y中对应的元素。

    1. x = tf.constant([[2, 2], [3, 3]])
    2. y = tf.constant([[8, 16], [2, 3]])
    3. tf.pow(x, y)  # [[256, 65536], [9, 27]]

    参数：

    • x:类型为float16、float32、float64、int32、int64、complex64或complex128的张量。
    • y:类型为float16、float32、float64、int32、int64、complex64或complex128的张量。
    • name:操作的名称(可选)。

    返回值：

    • 一个张量。

    __rsub__

    1. __rsub__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    返回x - y元素。注:减支持广播。

    参数：

    • x:张量。必须是以下类型之一:bfloat16、half、float32、float64、uint8、int8、uint16、int16、int32、int64、complex64、complex128。
    • y:张量。必须具有与x相同的类型。
    • name:操作的名称(可选)。

    返回值：

    • 一个张量。与x类型相同。

    __rtruediv__

    1. __rtruediv__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    __rxor__

    1. __rxor__(
    2.     a,
    3.     *args,
    4.     **kwargs
    5. )

    逻辑异或函数。x ^ y = (x | y) & ~(x & y)输入为张量，如果张量包含多个元素，则计算元素逻辑XOR。

    用法：

    1. x = tf.constant([False, False, True, True], dtype = tf.bool)
    2. y = tf.constant([False, True, False, True], dtype = tf.bool)
    3. z = tf.logical_xor(x, y, name="LogicalXor")
    4. #  here z = [False  True  True False]

    参数：

    • x:张量类型bool。
    • y: bool型张量。

    返回值：

    • 一个bool类型的张量，与x或y的张量大小相同。

    assign

    1. assign(
    2.     value,
    3.     use_locking=False,
    4.     name=None,
    5.     read_value=True
    6. )

    为变量分配一个新值。这本质上是赋值(self, value)的快捷方式。

    参数：

    • value:一个张量。这个变量的新值。
    • use_lock:如果为真，则在赋值期间使用锁定。
    • name:要创建的操作的名称
    • read_value:如果为真，将返回值为变量新值的值;if False将返回赋值op。

    返回：

    • 一个张量，它将在赋值完成后保留这个变量的新值。

    assign_add

    1. assign_add(
    2.     delta,
    3.     use_locking=False,
    4.     name=None,
    5.     read_value=True
    6. )

    为该变量添加一个值。这实际上是assign_add(self, delta)的快捷方式。

    参数：

    • delta:张量。要添加到此变量的值。
    • use_lock:如果为真，则在操作期间使用锁定。
    • name:要创建的操作的名称
    • read_value:如果为真，将返回值为变量新值的值;if False将返回赋值op。

    返回值：

    • 一个张量，它将在加法完成后保留这个变量的新值。

    assign_sub

    1. assign_sub(
    2.     delta,
    3.     use_locking=False,
    4.     name=None,
    5.     read_value=True
    6. )

    从这个变量中减去一个值。这实际上是assign_sub(self, delta)的快捷方式。

    参数：

    • delta:张量。从这个变量中减去的值。
    • use_lock:如果为真，则在操作期间使用锁定。
    • name:要创建的操作的名称
    • read_value:如果为真，将返回值为变量新值的值;if False将返回赋值op。

    返回值：

    • 一个张量，它将在减法完成后保留这个变量的新值。

    batch_scatter_update

    1. batch_scatter_update(
    2.     sparse_delta,
    3.     use_locking=False,
    4.     name=None
    5. )

    类似于批量收集。indexedslice按批处理方式指向此变量。类似于batch_gather。这假设这个变量和sparse_delta indexedslice有一系列对它们都相同的主导维度，并且更新是在索引的最后一个维度上执行的。换句话说，维度应该如下:num_prefix_dims = sparse_delta. indexes。batch_dim = num_prefix_dims + 1 sparse_delta.updates。= sparse_delta.indices形状。shape + var.shape[batch_dim:]，其中更新了sparse_delta.updates。[:num_prefix_dims] = = sparse_delta.indices形状。shape[:num_prefix_dims] == var.shape[:num_prefix_dims]，所执行的操作可以表示为:var[i_1，…、i_n sparse_delta。指数(i_1,……， i_n, j]] = sparse_delta。更新(i_1,……， i_n, j]。指标是一维张量，这个操作等价于scatter_update。为了避免这种操作，可以循环遍历变量的第一个ndims，并对分割第一个维度的子张量使用scatter_update。对于ndims = 1，这是一个有效的选项，但是比这个实现的效率要低。

    参数：

    • sparse_delta: tf。要分配给该变量的indexedslice。
    • use_lock:如果为真，则在操作期间使用锁定。
    • name:操作的名称。

    返回值：

    • 一个张量，它将在分散分配完成后保留这个变量的新值。

    可能产生的异常：

    • TypeError: if sparse_delta is not an IndexedSlices.

    count_up_to

    count_up_to(limit)

    递增此变量，直到它达到极限。(不推荐)当运行Op时，它试图将变量增加1。如果增加变量会使其超过限制，那么Op将抛出异常OutOfRangeError。如果没有引起错误，Op将在增量之前输出变量的值。这实际上是count_up_to(self, limit)的快捷方式。

    参数：

    • limit:值，在该值处递增变量会引发错误。

    返回值：

    • 一个张量，它将在增量之前保持变量值。如果没有其他Op修改这个变量，那么生成的值都是不同的。

    eval

    eval(session=None)

    在会话中，计算并返回此变量的值。这不是一个图形构造方法，它不向图形添加ops。这个方便的方法需要一个会话，其中包含这个变量的图已经启动。如果没有传递会话，则使用默认会话。有关启动图表和会话的更多信息，请参见tf.compat.v1.Session。

    1. v = tf.Variable([1, 2])
    2. init = tf.compat.v1.global_variables_initializer()
    3.  
    4. with tf.compat.v1.Session() as sess:
    5.     sess.run(init)
    6.     # Usage passing the session explicitly.
    7.     print(v.eval(sess))
    8.     # Usage with the default session.  The 'with' block
    9.     # above makes 'sess' the default session.
    10.     print(v.eval())

    参数：

    • session:用来计算这个变量的会话。如果没有，则使用默认会话。

    返回值：

    • 带有此变量值副本的numpy ndarray。

    experimental_ref

    experimental_ref()

    返回此变量的可刷新引用对象。这个API的主要用途是将变量放在set/dictionary中。我们不能把变量放在set/dictionary中，因为变量变量在启动Tensorflow 2.0时不再可用。

    1. import tensorflow as tf
    2.  
    3. x = tf.Variable(5)
    4. y = tf.Variable(10)
    5. z = tf.Variable(10)
    6.  
    7. # The followings will raise an exception starting 2.0
    8. # TypeError: Variable is unhashable if Variable equality is enabled.
    9. variable_set = {x, y, z}
    10. variable_dict = {x: 'five', y: 'ten'}

    相反，我们可以使用variable.experimental al_ref()。

    1. variable_set = {x.experimental_ref(),
    2.                 y.experimental_ref(),
    3.                 z.experimental_ref()}
    4.  
    5. print(x.experimental_ref() in variable_set)
    6. ==> True
    7.  
    8. variable_dict = {x.experimental_ref(): 'five',
    9.                  y.experimental_ref(): 'ten',
    10.                  z.experimental_ref(): 'ten'}
    11.  
    12. print(variable_dict[y.experimental_ref()])
    13. ==> ten

    此外，reference对象提供.deref()函数，该函数返回原始变量。

    1. x = tf.Variable(5)
    2. print(x.experimental_ref().deref())
    3. ==> 'Variable:0' shape=() dtype=int32, numpy=5>

    from_proto

    1. @staticmethod
    2. from_proto(
    3.     variable_def,
    4.     import_scope=None
    5. )

    返回一个由variable_def创建的变量对象。

    gather_nd

    1. gather_nd(
    2.     indices,
    3.     name=None
    4. )

    将params中的切片收集到一个由指标指定形状的张量中。

    参数：

    • indices:一个张量。必须是下列类型之一:int32、int64。指数张量。
    • name:操作的名称(可选)。

    返回值：

    • 一个张量。具有与params相同的类型。

    get_shape

    get_shape()

    Variable.shape的别名。

    initialized_value

    initialized_value()

    返回初始化变量的值。(弃用)。你应该使用它而不是变量本身来初始化另一个变量，该变量的值取决于该变量的值。

    1. # Initialize 'v' with a random tensor.
    2. v = tf.Variable(tf.random.truncated_normal([10, 40]))
    3. # Use `initialized_value` to guarantee that `v` has been
    4. # initialized before its value is used to initialize `w`.
    5. # The random values are picked only once.
    6. w = tf.Variable(v.initialized_value() * 2.0)

    返回值：

    • 一个张量，在它的初始化器运行后保持这个变量的值。

    load

    1. load(
    2.     value,
    3.     session=None
    4. )

    将新值加载到该变量中。(弃用)警告:不推荐使用此函数。它将在未来的版本中被删除。更新说明:首选变量。在2.X中具有相同行为的赋值。将新值写入变量的内存。没有向图中添加ops。这个方便的方法需要一个会话，其中包含这个变量的图已经启动。如果没有传递会话，则使用默认会话。有关启动图表和会话的更多信息，请参见tf.compat.v1.Session。

    1. v = tf.Variable([1, 2])
    2. init = tf.compat.v1.global_variables_initializer()
    3.  
    4. with tf.compat.v1.Session() as sess:
    5.     sess.run(init)
    6.     # Usage passing the session explicitly.
    7.     v.load([2, 3], sess)
    8.     print(v.eval(sess)) # prints [2 3]
    9.     # Usage with the default session.  The 'with' block
    10.     # above makes 'sess' the default session.
    11.     v.load([3, 4], sess)
    12.     print(v.eval()) # prints [3 4]

    参数：

    • value:新变量值
    • session:用来计算这个变量的会话。如果没有，则使用默认会话。

    可能产生的异常：

    • ValueError: Session is not passed and no default session

    read_value

    read_value()

    返回在当前上下文中读取的此变量的值。与value()不同，如果它在另一个设备上，具有控件依赖关系，等等。

    返回值：

    • 包含变量值的张量。

    scatter_add

    1. scatter_add(
    2.     sparse_delta,
    3.     use_locking=False,
    4.     name=None
    5. )

    参数：

    • sparse_delta: tf。要添加到此变量的indexedslice。
    • use_lock:如果为真，则在操作期间使用锁定。
    • name:操作的名称。

    返回值：

    • 一个张量，它将在散射加法完成后保持这个变量的新值。

    可能产生的异常：

    • TypeError: if sparse_delta is not an IndexedSlices.

    scatter_div

    1. scatter_div(
    2.     sparse_delta,
    3.     use_locking=False,
    4.     name=None
    5. )

    将这个变量除以tf. indexedslice。

    参数：

    • sparse_delta: tf。indexedslice将这个变量除以。
    • use_lock:如果为真，则在操作期间使用锁定。
    • name:操作的名称。

    返回值：

    • 一个张量，它将在离散除法完成后保留这个变量的新值。

    可能产生的异常：

    • TypeError: if sparse_delta is not an IndexedSlices.

    scatter_max

    1. scatter_max(
    2.     sparse_delta,
    3.     use_locking=False,
    4.     name=None
    5. )

    用tf的最大值更新此变量。IndexedSlices和本身。

    参数：

    • sparse_delta: tf。indexedslice使用这个变量作为max的参数。
    • use_lock:如果为真，则在操作期间使用锁定。
    • name:操作的名称。

    返回值：

    • 一个张量，它将在分散最大化完成后持有这个变量的新值。

    可能产生的异常：

    • TypeError: if sparse_delta is not an IndexedSlices.

    scatter_min

    1. scatter_min(
    2.     sparse_delta,
    3.     use_locking=False,
    4.     name=None
    5. )

    用tf的最小值更新这个变量。IndexedSlices和本身。

    参数：

    • sparse_delta: tf。indexedslice使用这个变量作为min的参数。
    • use_lock:如果为真，则在操作期间使用锁定。
    • name:操作的名称。

    返回值：

    • 一个张量，它将在离散极小化完成后保持这个变量的新值。

    可能产生的异常：

    • TypeError: if sparse_delta is not an IndexedSlices.

    scatter_mul

    1. scatter_mul(
    2.     sparse_delta,
    3.     use_locking=False,
    4.     name=None
    5. )

    将这个变量乘以tf. indexedslice。

    将这个变量乘以tf. indexedslice。

    参数：

    • sparse_delta: tf.indexedslice将这个变量乘以。
    • use_lock:如果为真，则在操作期间使用锁定。
    • name:操作的名称。

    返回值：

    • 一个张量，它将在散乘完成后保留这个变量的新值。

    可能产生的异常：

    • TypeError: if sparse_delta is not an IndexedSlices.

    scatter_nd_add

    1. scatter_nd_add(
    2.     indices,
    3.     updates,
    4.     name=None
    5. )

    对变量中的单个值或片应用稀疏加法。变量的秩为P，指标是秩为q的张量。指标必须是整数张量，包含自指标。它必须是shape [d_0，…， d_{Q-2}， K]，其中0 < K <= P。索引的最内层维度(长度为K)对应于沿着self的第K个维度的元素索引(如果K = P)或切片索引(如果K < P)。更新量为Q-1+P-K阶张量，形状为:

    [d_0, ..., d_{Q-2}, self.shape[K], ..., self.shape[P-1]].

    例如，我们想把4个散射元素加到一个秩为1的张量到8个元素上。在Python中，更新应该是这样的:

    1.  v = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
    2.  indices = tf.constant([[4], [3], [1] ,[7]])
    3.  updates = tf.constant([9, 10, 11, 12])
    4.  add = v.scatter_nd_add(indices, updates)
    5.  with tf.compat.v1.Session() as sess:
    6.       print sess.run(add)

    v的最终更新如下:

    [1, 13, 3, 14, 14, 6, 7, 20]

    有关如何更新片的详细信息，请参阅scatter_nd。

    参数：

    • indices:用于操作的索引。
    • updates:操作中使用的值。
    • name:操作的名称。

    返回值：

    • 一个张量，它将在散射加法完成后保持这个变量的新值。

    scatter_nd_sub

    1. scatter_nd_sub(
    2.     indices,
    3.     updates,
    4.     name=None
    5. )

    假设变量的秩为P，指标是秩为q的张量，指标必须是整数张量，包含自指标。它必须是shape [d_0，…， d_{Q-2}， K]，其中0 < K <= P。索引的最内层维度(长度为K)对应于沿着self的第K个维度的元素索引(如果K = P)或切片索引(如果K < P)。更新量为Q-1+P-K阶张量，形状为:

    [d_0, ..., d_{Q-2}, self.shape[K], ..., self.shape[P-1]].

    例如，我们想把4个散射元素加到一个秩为1的张量到8个元素上。在Python中，更新应该是这样的：

    1. v = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
    2. indices = tf.constant([[4], [3], [1] ,[7]])
    3. updates = tf.constant([9, 10, 11, 12])
    4. op = v.scatter_nd_sub(indices, updates)
    5. with tf.compat.v1.Session() as sess:
    6.    print sess.run(op)

    v的最终更新如下：

    [1, -9, 3, -6, -6, 6, 7, -4]

    有关如何更新片的详细信息，请参阅scatter_nd。

    参数：

    • indices:用于操作的索引。
    • updates:操作中使用的值。
    • name:操作的名称。

    返回值：

    • 一个张量，它将在散差减法完成后保留这个变量的新值。

    scatter_nd_update

    1. scatter_nd_update(
    2.     indices,
    3.     updates,
    4.     name=None
    5. )

    对变量中的单个值或片应用稀疏赋值。变量的秩为P，指标是秩为q的张量。指标必须是整数张量，包含自指标。它必须是shape [d_0，…， d_{Q-2}， K]，其中0 < K <= P。索引的最内层维度(长度为K)对应于沿着self的第K个维度的元素索引(如果K = P)或切片索引(如果K < P)。更新量为Q-1+P-K阶张量，形状为：

    [d_0, ..., d_{Q-2}, self.shape[K], ..., self.shape[P-1]].

    例如，我们想把4个散射元素加到一个秩为1的张量到8个元素上。在Python中，更新应该是这样的:

    1. v = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
    2. indices = tf.constant([[4], [3], [1] ,[7]])
    3. updates = tf.constant([9, 10, 11, 12])
    4. op = v.scatter_nd_assign(indices, updates)
    5. with tf.compat.v1.Session() as sess:
    6.    print sess.run(op)

    v的最终更新如下:

    [1, 11, 3, 10, 9, 6, 7, 12]

    有关如何更新片的详细信息，请参阅scatter_nd。

    参数：

    • indices:用于操作的索引。
    • updates:操作中使用的值。
    • name:操作的名称。

    返回值：

    • 一个张量，它将在分散分配完成后保留这个变量的新值。

    scatter_sub

    1. scatter_sub(
    2.     sparse_delta,
    3.     use_locking=False,
    4.     name=None
    5. )

    从这个变量索引切片。

    参数：

    • sparse_delta: tf。要从该变量中减去的indexedslice。
    • use_lock:如果为真，则在操作期间使用锁定。
    • name:操作的名称。

    返回值：

    • 一个张量，它将在散差减法完成后保留这个变量的新值。

    可能产生的异常：

    • TypeError: if sparse_delta is not an IndexedSlices.

    scatter_update

    1. scatter_update(
    2.     sparse_delta,
    3.     use_locking=False,
    4.     name=None
    5. )

    indexedslice指向这个变量。

    参数值：

    • sparse_delta: 要分配给该变量的tf.indexedslice。
    • use_lock:如果为真，则在操作期间使用锁定。
    • name:操作的名称。

    返回值：

    • 一个张量，它将在分散分配完成后保留这个变量的新值。

    可能产生的异常：

    • TypeError: if sparse_delta is not an IndexedSlices.

    set_shape

    set_shape(shape)

    覆盖此变量的形状。

    参数：

    • shape:表示被覆盖的形状的TensorShape。

    sparse_read

    1. sparse_read(
    2.     indices,
    3.     name=None
    4. )

    根据索引从params坐标轴中收集切片。这个函数支持tf的一个子集。收集,请参阅特遣部队。

    参数：

    • indices:指标张量。必须是下列类型之一:int32、int64。必须在range [0, params.shape[axis]]中。
    • name:操作的名称(可选)。

    返回值：

    • 一个张量。具有与params相同的类型。

    to_proto

    to_proto(export_scope=None)

    将变量转换为VariableDef协议缓冲区。

    参数：

    • export_scope:可选的字符串。名称要删除的范围。

    返回值：

    • 一个VariableDef协议缓冲区，如果变量不在指定的名称范围内，则为None。

    value

    value()

    返回此变量的最后一个快照。通常不需要调用这个方法，因为所有需要变量值的ops都会通过调用convert_to_张量()自动调用它。返回一个包含变量值的张量。你不能给这个张量赋一个新的值，因为它不是对变量的引用。为了避免复制，如果返回值的使用者与变量位于相同的设备上，那么实际上将返回变量的活动值，而不是复制。消费者可以看到变量的更新。如果使用者在不同的设备上，它将获得变量的副本。

    返回值：

    • 包含变量值的张量。
  • 相关阅读:
    Linux部署Spark 本地模式
    【PAT甲级】1010 Radix
    一个程序员的成长之路
    SpringCloud微服务（十一）——Sentinel服务熔断限流
    office办公软件太贵了 Microsoft的Word为什么要买 Microsoft365家庭版多少钱 Microsoft365密钥
    二、主流的架构方法论
    关于动态内存管理中的常见练习题
    MySQL约束
    数据库基础入门 — SQL
    Ubuntu Seata开机自启动服务
  • 原文地址：https://blog.csdn.net/weixin_36670529/article/details/100155660