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)