Python state_ops.variable_op函数代码示例

 def testAssignNoValueShapeNoValidateShape(self):
   value = self._NewShapelessTensor()
   shape = [1, 2]
   var = state_ops.variable_op(shape, dtypes.float32)
   self.assertEqual(shape, var.get_shape())
   assigned = state_ops.assign(var, value, validate_shape=False)
   self.assertEqual(tensor_shape.unknown_shape(), assigned.get_shape())

 def testAssignNoShape(self):
   with self.cached_session():
     value = self._NewShapelessTensor()
     var = state_ops.variable_op([1, 2], dtypes.float32, set_shape=False)
     self.assertEqual(tensor_shape.unknown_shape(), var.get_shape())
     self.assertEqual(tensor_shape.unknown_shape(),
                      state_ops.assign(var, value).get_shape())

 def testIsVariableInitialized(self):
   for use_gpu in [True, False]:
     with self.test_session(use_gpu=use_gpu):
       v0 = state_ops.variable_op([1, 2], dtypes.float32)
       self.assertEqual(False, variables.is_variable_initialized(v0).eval())
       state_ops.assign(v0, [[2.0, 3.0]]).eval()
       self.assertEqual(True, variables.is_variable_initialized(v0).eval())

 def testAssignNoValueShape(self):
   value = self._NewShapelessTensor()
   shape = [1, 2]
   var = state_ops.variable_op(shape, dtypes.float32)
   assigned = state_ops.assign(var, value)
   self.assertEqual(shape, var.get_shape())
   self.assertEqual(shape, assigned.get_shape())

 def testAssignNoShapeNoValidateShape(self):
   with self.test_session():
     value = self._NewShapelessTensor()
     var = state_ops.variable_op([1, 2], tf.float32, set_shape=False)
     self.assertEqual(tensor_shape.unknown_shape(), var.get_shape())
     self.assertEqual(tensor_shape.unknown_shape(),
                      tf.assign(var, value, validate_shape=False).get_shape())

  def __init__(self, initial_value, trainable=True, collections=None,
               validate_shape=True, name=None):
    """Creates a new variable with value `initial_value`.

    The new variable is added to the graph collections listed in `collections`,
    which defaults to `[GraphKeys.VARIABLES]`.

    If `trainable` is `True` the variable is also added to the graph collection
    `GraphKeys.TRAINABLE_VARIABLES`.

    This constructor creates both a `variable` Op and an `assign` Op to set the
    variable to its initial value.

    Args:
      initial_value: A `Tensor`, or Python object convertible to a `Tensor`.
        The initial value for the Variable. Must have a shape specified unless
        `validate_shape` is set to False.
      trainable: If `True`, the default, also adds the variable to the graph
        collection `GraphKeys.TRAINABLE_VARIABLES`. This collection is used as
        the default list of variables to use by the `Optimizer` classes.
      collections: List of graph collections keys. The new variable is added to
        these collections. Defaults to `[GraphKeys.VARIABLES]`.
      validate_shape: If `False`, allows the variable to be initialized with a
        value of unknown shape. If `True`, the default, the shape of
        `initial_value` must be known.
      name: Optional name for the variable. Defaults to `'Variable'` and gets
        uniquified automatically.

    Returns:
      A Variable.

    Raises:
      ValueError: If the initial value does not have a shape and
        `validate_shape` is `True`.
    """
    if collections is None:
      collections = [ops.GraphKeys.VARIABLES]
    if trainable and ops.GraphKeys.TRAINABLE_VARIABLES not in collections:
      collections = list(collections) + [ops.GraphKeys.TRAINABLE_VARIABLES]
    with ops.control_dependencies(None):
      with ops.op_scope([initial_value], name, "Variable") as name:
        self._initial_value = ops.convert_to_tensor(initial_value,
                                                    name="initial_value")
        initial_value_shape = self._initial_value.get_shape()
        if validate_shape and not initial_value_shape.is_fully_defined():
          raise ValueError("initial_value must have a shape specified: %s"
                           % self._initial_value)
        shape_to_set = initial_value_shape if validate_shape else []
        self._variable = state_ops.variable_op(
            shape_to_set, self._initial_value.dtype.base_dtype,
            set_shape=validate_shape, name=name)
        with ops.device(self._variable.device):
          self._initializer_op = state_ops.assign(
              self._variable, self._initial_value,
              validate_shape=validate_shape).op
          self._snapshot = array_ops.identity(self._variable, name="read")

    ops.add_to_collections(collections, self)
    self._save_slice_info = None

  def _init_from_args(self, initial_value=None, trainable=True,
                      collections=None, validate_shape=True,
                      caching_device=None, name=None):
    """Creates a new variable from arguments.

    Args:
      initial_value: A `Tensor`, or Python object convertible to a `Tensor`.
        The initial value for the Variable. Must have a shape specified unless
        `validate_shape` is set to False.
      trainable: If `True`, the default, also adds the variable to the graph
        collection `GraphKeys.TRAINABLE_VARIABLES`. This collection is used as
        the default list of variables to use by the `Optimizer` classes.
      collections: List of graph collections keys. The new variable is added to
        these collections. Defaults to `[GraphKeys.VARIABLES]`.
      validate_shape: If `False`, allows the variable to be initialized with a
        value of unknown shape. If `True`, the default, the shape of
        `initial_value` must be known.
      caching_device: Optional device string or function describing where the
        Variable should be cached for reading.  Defaults to the Variable's
        device.  If not `None`, caches on another device.  Typical use is to
        cache on the device where the Ops using the Variable reside, to
        deduplicate copying through `Switch` and other conditional statements.
      name: Optional name for the variable. Defaults to `'Variable'` and gets
        uniquified automatically.

    Raises:
      ValueError: If the initial value is not specified, or does not have a
        shape and `validate_shape` is `True`.
    """
    if initial_value is None:
      raise ValueError("initial_value must be specified.")
    if collections is None:
      collections = [ops.GraphKeys.VARIABLES]
    if trainable and ops.GraphKeys.TRAINABLE_VARIABLES not in collections:
      collections = list(collections) + [ops.GraphKeys.TRAINABLE_VARIABLES]
    with ops.control_dependencies(None):
      with ops.op_scope([initial_value], name, "Variable") as name:
        self._initial_value = ops.convert_to_tensor(initial_value,
                                                    name="initial_value")
        initial_value_shape = self._initial_value.get_shape()
        if validate_shape and not initial_value_shape.is_fully_defined():
          raise ValueError("initial_value must have a shape specified: %s"
                           % self._initial_value)
        shape_to_set = initial_value_shape if validate_shape else []
        self._variable = state_ops.variable_op(
            shape_to_set, self._initial_value.dtype.base_dtype,
            set_shape=validate_shape, name=name)
        with ops.device(self._variable.device):
          self._initializer_op = state_ops.assign(
              self._variable, self._initial_value,
              validate_shape=validate_shape).op
        with ops.device(caching_device if caching_device is not None
                        else self._variable.device):
          self._snapshot = array_ops.identity(self._variable, name="read")

    ops.add_to_collections(collections, self)
    self._caching_device = caching_device
    self._save_slice_info = None

 def testAssignDependencyAcrossDevices(self):
   with self.test_session(use_gpu=True):
     # The variable and an op to increment it are on the GPU.
     var = state_ops.variable_op([1], tf.float32)
     tf.assign(var, [1.0]).eval()
     increment = tf.assign_add(var, [1.0])
     with tf.control_dependencies([increment]):
       with tf.device("/cpu:0"):
         # This mul op is pinned to the CPU, but reads the variable from the
         # GPU. The te

 def testAverageVariablesDeviceAssignment(self):
   with ops.device("dev_v0"):
     v0 = variables.Variable(10.0, name="v0")
   with ops.device("dev_v1"):
     v1 = state_ops.variable_op(shape=[1], dtype=types.float32, name="v1")
   tensor2 = v0 + v1
   ema = moving_averages.ExponentialMovingAverage(0.25, name="foo_avg")
   with ops.device("default"):
     ema.apply([v0, v1, tensor2])
   self.assertEqual("dev_v0", ema.average(v0).device)
   self.assertEqual("dev_v1", ema.average(v1).device)
   self.assertEqual("default", ema.average(tensor2).device)

 def testAssignDependencyAcrossDevices(self):
   with test_util.use_gpu():
     # The variable and an op to increment it are on the GPU.
     var = state_ops.variable_op([1], dtypes.float32)
     self.evaluate(state_ops.assign(var, [1.0]))
     increment = state_ops.assign_add(var, [1.0])
     with ops.control_dependencies([increment]):
       with test_util.force_cpu():
         # This mul op is pinned to the CPU, but reads the variable from the
         # GPU. The test ensures that the dependency on 'increment' is still
         # honored, i.e., the Send and Recv from GPU to CPU should take place
         # only after the increment.
         result = math_ops.multiply(var, var)
     self.assertAllClose([4.0], self.evaluate(result))

 def _buildInitialVars(self, shape, dev_list):
   values = []
   num_devices = len(dev_list)
   dim = np.prod(shape) if shape else 1
   for d in range(0, num_devices):
     with ops.device(dev_list[d]):
       npt = np.zeros(shape).astype(np.float32)
       alias = np.frombuffer(npt.data, dtype=np.float32)
       for i in range(0, dim):
         alias[i] = i + 0.01 * d
       var = state_ops.variable_op(shape, types_pb2.DT_FLOAT)
       state_ops.init_variable(var, npt).op.run()
       values.append(var)
   return values

 def testObtainNext(self):
   with self.test_session():
     var = state_ops.variable_op([1], tf.int64)
     tf.assign(var, [-1]).op.run()
     c = tf.constant(["a", "b"])
     sample1 = input_pipeline_ops.obtain_next(c, var)
     self.assertEqual(b"a", sample1.eval())
     self.assertEqual([0], var.eval())
     sample2 = input_pipeline_ops.obtain_next(c, var)
     self.assertEqual(b"b", sample2.eval())
     self.assertEqual([1], var.eval())
     sample3 = input_pipeline_ops.obtain_next(c, var)
     self.assertEqual(b"a", sample3.eval())
     self.assertEqual([0], var.eval())

 def testObtainNext(self):
   with self.test_session():
     var = state_ops.variable_op([], dtypes.int64)
     state_ops.assign(var, -1).op.run()
     c = constant_op.constant(["a", "b"])
     sample1 = input_pipeline_ops.obtain_next(c, var)
     self.assertEqual(b"a", sample1.eval())
     self.assertEqual(0, var.eval())
     sample2 = input_pipeline_ops.obtain_next(c, var)
     self.assertEqual(b"b", sample2.eval())
     self.assertEqual(1, var.eval())
     sample3 = input_pipeline_ops.obtain_next(c, var)
     self.assertEqual(b"a", sample3.eval())
     self.assertEqual(0, var.eval())

 def testAssignDependencyAcrossDevices(self):
   with self.test_session(use_gpu=True):
     # The variable and an op to increment it are on the GPU.
     var = state_ops.variable_op([1], tf.float32)
     tf.assign(var, [1.0]).eval()
     increment = tf.assign_add(var, [1.0])
     with tf.control_dependencies([increment]):
       with tf.device("/cpu:0"):
         # This mul op is pinned to the CPU, but reads the variable from the
         # GPU. The test ensures that the dependency on 'increment' is still
         # honored, i.e., the Send and Recv from GPU to CPU should take place
         # only after the increment.
         result = tf.mul(var, var)
     self.assertAllClose([4.0], result.eval())

 def testAverageVariablesDeviceAssignment(self):
   with tf.device("/job:dev_v0"):
     v0 = tf.Variable(10.0, name="v0")
   with tf.device("/job:dev_v1"):
     v1 = state_ops.variable_op(shape=[1], dtype=tf.float32, name="v1")
   tensor2 = v0 + v1
   ema = tf.train.ExponentialMovingAverage(0.25, name="foo_avg")
   with tf.device("/job:default"):
     ema.apply([v0, v1, tensor2])
   self.assertDeviceEqual("/job:dev_v0", ema.average(v0).device)
   self.assertDeviceEqual("/job:dev_v1", ema.average(v1).device)
   # However, the colocation property is maintained.
   self.assertEqual([b"loc:@v1"],
                    ema.average(v1).op.colocation_groups())
   self.assertDeviceEqual("/job:default", ema.average(tensor2).device)