Python gen_nn_ops._softmax_cross_entropy_with_logits函数代码示例

def softmax_cross_entropy_with_logits(logits, labels, name=None):
    """Computes softmax cross entropy between `logits` and `labels`.

  Measures the probability error in discrete classification tasks in which the
  classes are mutually exclusive (each entry is in exactly one class).  For
  example, each CIFAR-10 image is labeled with one and only one label: an image
  can be a dog or a truck, but not both.

  **NOTE:**  While the classes are mutually exclusive, their probabilities
  need not be.  All that is required is that each row of `labels` is
  a valid probability distribution.  If using exclusive `labels`
  (wherein one and only one class is true at a time), see
  `sparse_softmax_cross_entropy_with_logits`.

  **WARNING:** This op expects unscaled logits, since it performs a `softmax`
  on `logits` internally for efficiency.  Do not call this op with the
  output of `softmax`, as it will produce incorrect results.

  `logits` and `labels` must have the same shape `[batch_size, num_classes]`
  and the same dtype (either `float32` or `float64`).

  Args:
    logits: Unscaled log probabilities.
    labels: Each row `labels[i]` must be a valid probability distribution.
    name: A name for the operation (optional).

  Returns:
    A 1-D `Tensor` of length `batch_size` of the same type as `logits` with the
    softmax cross entropy loss.
  """
    # The second output tensor contains the gradients.  We use it in
    # _CrossEntropyGrad() in nn_grad but not here.
    cost, unused_backprop = gen_nn_ops._softmax_cross_entropy_with_logits(logits, labels, name=name)
    return cost

 def _testXent(self, np_features, np_labels, use_gpu=False):
     np_loss, np_backprop = self._npXent(np_features, np_labels)
     with self.test_session(use_gpu=use_gpu) as sess:
         loss, backprop = gen_nn_ops._softmax_cross_entropy_with_logits(np_features, np_labels)
         tf_loss, tf_backprop = sess.run([loss, backprop])
     self.assertAllCloseAccordingToType(np_loss, tf_loss)
     self.assertAllCloseAccordingToType(np_backprop, tf_backprop)

 def _testSingleClass(self, use_gpu=False):
   for dtype in np.float16, np.float32:
     with self.test_session(use_gpu=use_gpu) as sess:
       loss, backprop = gen_nn_ops._softmax_cross_entropy_with_logits(
           np.array([[1.], [-1.], [0.]]).astype(dtype),
           np.array([[-1.], [0.], [1.]]).astype(dtype))
       tf_loss, tf_backprop = sess.run([loss, backprop])
     self.assertAllClose([0.0, 0.0, 0.0], tf_loss)
     self.assertAllClose([[2.0], [1.0], [0.0]], tf_backprop)

 def testNotMatrix(self):
   with self.test_session():
     with self.assertRaises(ValueError):
       gen_nn_ops._softmax_cross_entropy_with_logits([0., 1., 2., 3.],
                                                     [0., 1., 0., 1.])

 def testShapeMismatch(self):
   with self.test_session():
     with self.assertRaises(ValueError):
       gen_nn_ops._softmax_cross_entropy_with_logits(
           [[0., 1.], [2., 3.]], [[0., 1., 0.], [1., 0., 0.]])