Beispiel #1
0
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)
Beispiel #2
0
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)
Beispiel #3
0
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)
Beispiel #4
0
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)
Beispiel #5
0
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)