def init_variable(v, init, name="init"):
"""Initializes variable with "init".
This op does the following:
if init is a Tensor, v = init
if callable(init): v = init(VariableShape(v), v.dtype)
Args:
v: Variable to initialize
init: Tensor to assign to v,
Or an object convertible to Tensor e.g. nparray,
Or an Initializer that generates a tensor given the shape and type of v.
An "Initializer" is a callable that returns a tensor that "v" should be
set to. It will be called as init(shape, dtype).
name: Optional name for the op.
Returns:
The operation that initializes v.
"""
with ops.name_scope(None, v.op.name + "/", [v, init]):
with ops.name_scope(name) as scope:
with ops.colocate_with(v):
if callable(init):
assert v.get_shape().is_fully_defined(), "Variable shape unknown."
# TODO(mrry): Convert to v.shape when the property and
# accessor are reconciled (and all initializers support
# tf.TensorShape objects).
value = init(v.get_shape().as_list(), v.dtype.base_dtype)
value = ops.convert_to_tensor(value, name="value")
return gen_state_ops.assign(v, value, name=scope)
else:
init = ops.convert_to_tensor(init, name="init")
return gen_state_ops.assign(v, init, name=scope)
def init_variable(v, init, name="init"):
"""Initializes variable with "init".
This op does the following:
if init is a Tensor, v = init
if callable(init): v = init(VariableShape(v), v.dtype)
Args:
v: Variable to initialize
init: Tensor to assign to v,
Or an object convertible to Tensor e.g. nparray,
Or an Initializer that generates a tensor given the shape and type of v.
An "Initializer" is a callable that returns a tensor that "v" should be
set to. It will be called as init(shape, dtype).
name: Optional name for the op.
Returns:
The operation that initializes v.
"""
with ops.name_scope(None, v.op.name + "/", [v, init]):
with ops.name_scope(name) as scope:
with ops.colocate_with(v):
if callable(init):
assert v.get_shape().is_fully_defined(
), "Variable shape unknown."
# TODO(mrry): Convert to v.shape when the property and
# accessor are reconciled (and all initializers support
# tf.TensorShape objects).
value = init(v.get_shape().as_list(), v.dtype.base_dtype)
value = ops.convert_to_tensor(value, name="value")
return gen_state_ops.assign(v, value, name=scope)
else:
init = ops.convert_to_tensor(init, name="init")
return gen_state_ops.assign(v, init, name=scope)
def assign(ref, value, validate_shape=None, use_locking=None, name=None):
"""Update 'ref' by assigning 'value' to it.
This operation outputs a Tensor that holds the new value of 'ref' after
the value has been assigned. This makes it easier to chain operations
that need to use the reset value.
Args:
ref: A mutable `Tensor`.
Should be from a `Variable` node. May be uninitialized.
value: A `Tensor`. Must have the same type as `ref`.
The value to be assigned to the variable.
validate_shape: An optional `bool`. Defaults to `True`.
If true, the operation will validate that the shape
of 'value' matches the shape of the Tensor being assigned to. If false,
'ref' will take on the shape of 'value'.
use_locking: An optional `bool`. Defaults to `True`.
If True, the assignment will be protected by a lock;
otherwise the behavior is undefined, but may exhibit less contention.
name: A name for the operation (optional).
Returns:
A `Tensor` that will hold the new value of 'ref' after
the assignment has completed.
"""
if ref.dtype._is_ref_dtype:
return gen_state_ops.assign(
ref, value, use_locking=use_locking, name=name,
validate_shape=validate_shape)
return ref.assign(value, name=name)
def assign(ref, value, validate_shape=None, use_locking=None, name=None):
"""Update 'ref' by assigning 'value' to it.
This operation outputs a Tensor that holds the new value of 'ref' after
the value has been assigned. This makes it easier to chain operations
that need to use the reset value.
Args:
ref: A mutable `Tensor`.
Should be from a `Variable` node. May be uninitialized.
value: A `Tensor`. Must have the same type as `ref`.
The value to be assigned to the variable.
validate_shape: An optional `bool`. Defaults to `True`.
If true, the operation will validate that the shape
of 'value' matches the shape of the Tensor being assigned to. If false,
'ref' will take on the shape of 'value'.
use_locking: An optional `bool`. Defaults to `True`.
If True, the assignment will be protected by a lock;
otherwise the behavior is undefined, but may exhibit less contention.
name: A name for the operation (optional).
Returns:
A `Tensor` that will hold the new value of 'ref' after
the assignment has completed.
"""
if ref.dtype._is_ref_dtype:
return gen_state_ops.assign(ref,
value,
use_locking=use_locking,
name=name,
validate_shape=validate_shape)
return ref.assign(value, name=name)
def RttAssign(ref, value, validate_shape=None, use_locking=None, name=None):
"""Update `ref` by assigning `value` to it."""
value = rtt_ts.convert_to_rtttensor(value)
ref = _get_rtt_var(ref)
if ref.dtype._is_ref_dtype:
return gen_state_ops.assign(
ref, value._raw, use_locking=use_locking, name=name,
validate_shape=validate_shape)
return ref.assign(value._raw, name=name)
def assign(ref, value, validate_shape=None, use_locking=None, name=None):
"""Update `ref` by assigning `value` to it.
This operation outputs a Tensor that holds the new value of `ref` after
the value has been assigned. This makes it easier to chain operations that
need to use the reset value.
Args:
ref: A mutable `Tensor`. Should be from a `Variable` node. May be
uninitialized.
value: A `Tensor`. Must have the same shape and dtype as `ref`. The value to
be assigned to the variable.
validate_shape: An optional `bool`. Defaults to `True`. If true, the
operation will validate that the shape of 'value' matches the shape of the
Tensor being assigned to. If false, 'ref' will take on the shape of
'value'.
use_locking: An optional `bool`. Defaults to `True`. If True, the assignment
will be protected by a lock; otherwise the behavior is undefined, but may
exhibit less contention.
name: A name for the operation (optional).
Returns:
A `Tensor` that will hold the new value of `ref` after
the assignment has completed.
@compatibility(TF2)
`tf.compat.v1.assign` is mostly compatible with eager
execution and `tf.function`. However, argument 'validate_shape' will be
ignored. To avoid shape validation, set 'shape' to tf.TensorShape(None) when
constructing the variable:
>>> import tensorflow as tf
>>> a = tf.Variable([1], shape=tf.TensorShape(None))
>>> tf.compat.v1.assign(a, [2,3])
To switch to the native TF2 style, one could use method 'assign' of
`tf.Variable`:
#### How to Map Arguments
| TF1 Arg Name | TF2 Arg Name | Note |
| :-------------------- | :-------------- | :------------------------- |
| `ref` | `self` | In `assign()` method |
| `value` | `value` | In `assign()` method |
| `validate_shape` | Not supported | Specify `shape` in the |
: : : constructor to replicate :
: : : behavior :
| `use_locking` | `use_locking` | In `assign()` method |
| `name` | `name` | In `assign()` method |
| - | `read_value` | Set to True to replicate |
: : : behavior (True is default) :
@end_compatibility
#### Before & After Usage Example
Before:
>>> with tf.Graph().as_default():
... with tf.compat.v1.Session() as sess:
... a = tf.compat.v1.Variable(0, dtype=tf.int64)
... sess.run(a.initializer)
... update_op = tf.compat.v1.assign(a, 2)
... res_a = sess.run(update_op)
... res_a
2
After:
>>> b = tf.Variable(0, dtype=tf.int64)
>>> res_b = b.assign(2)
>>> res_b.numpy()
2
"""
if ref.dtype._is_ref_dtype:
return gen_state_ops.assign(ref,
value,
use_locking=use_locking,
name=name,
validate_shape=validate_shape)
return ref.assign(value, name=name)
