| # Copyright 2016 The TensorFlow Authors. All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # ============================================================================== |
| """Tests for losses.""" |
| |
| from __future__ import absolute_import |
| from __future__ import division |
| from __future__ import print_function |
| |
| import numpy as np |
| |
| from tensorflow.python.framework import constant_op |
| from tensorflow.python.framework import dtypes |
| from tensorflow.python.framework import errors_impl |
| from tensorflow.python.framework import ops |
| from tensorflow.python.framework import random_seed |
| from tensorflow.python.framework import test_util |
| from tensorflow.python.ops import array_ops |
| from tensorflow.python.ops import init_ops |
| from tensorflow.python.ops import math_ops |
| from tensorflow.python.ops import random_ops |
| from tensorflow.python.ops import variable_scope |
| from tensorflow.python.ops import variables |
| from tensorflow.python.ops.losses import losses |
| from tensorflow.python.ops.losses import util |
| from tensorflow.python.platform import test |
| from tensorflow.python.training import momentum as momentum_lib |
| |
| |
| @test_util.run_deprecated_v1 |
| class AbsoluteDifferenceLossTest(test.TestCase): |
| |
| def setUp(self): |
| super(AbsoluteDifferenceLossTest, self).setUp() |
| self._predictions = constant_op.constant([4, 8, 12, 8, 1, 3], shape=(2, 3)) |
| self._labels = constant_op.constant([1, 9, 2, -5, -2, 6], shape=(2, 3)) |
| |
| def testValueErrorThrownWhenWeightIsNone(self): |
| with self.cached_session(): |
| with self.assertRaises(ValueError): |
| losses.absolute_difference( |
| self._predictions, self._predictions, weights=None) |
| |
| def testAllCorrectNoLossWeight(self): |
| loss = losses.absolute_difference(self._predictions, self._predictions) |
| with self.cached_session(): |
| self.assertAlmostEqual(0.0, self.evaluate(loss), 3) |
| |
| def testNonZeroLoss(self): |
| loss = losses.absolute_difference(self._labels, self._predictions) |
| with self.cached_session(): |
| self.assertAlmostEqual(5.5, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithPythonScalarWeight(self): |
| weights = 2.3 |
| loss = losses.absolute_difference(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(5.5 * weights, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithScalarTensorWeight(self): |
| weights = 2.3 |
| loss = losses.absolute_difference(self._labels, self._predictions, |
| constant_op.constant(weights)) |
| with self.cached_session(): |
| self.assertAlmostEqual(5.5 * weights, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithOneDimBatchSpecificWeights(self): |
| weights = constant_op.constant((1.2, 0.0), shape=(2, 1)) |
| loss = losses.absolute_difference(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(5.6, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithTwoDimBatchSpecificWeights(self): |
| weights = constant_op.constant([1.2, 0.0], shape=[2, 1]) |
| loss = losses.absolute_difference(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(5.6, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithSampleSpecificWeights(self): |
| weights = constant_op.constant([3, 6, 5, 0, 4, 2], shape=[2, 3]) |
| loss = losses.absolute_difference(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(16.6, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithSampleSpecificWeightsMostZero(self): |
| weights = constant_op.constant([0, 0, 0, 0, 0, 2], shape=[2, 3]) |
| loss = losses.absolute_difference(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(6.0, self.evaluate(loss), 3) |
| |
| def testLossWithSampleSpecificWeightsAllZero(self): |
| weights = array_ops.zeros((2, 3)) |
| loss = losses.absolute_difference(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(0.0, self.evaluate(loss), 3) |
| |
| @test_util.assert_no_new_pyobjects_executing_eagerly |
| def testEagerNoMemoryLeaked(self): |
| # This is a somewhat convoluted way of testing that nothing gets added to |
| # a global collection. |
| predictions = constant_op.constant([4, 8, 12, 8, 1, 3], shape=(2, 3)) |
| labels = constant_op.constant([1, 9, 2, -5, -2, 6], shape=(2, 3)) |
| losses.absolute_difference(labels, predictions) |
| |
| |
| class SoftmaxCrossEntropyLossTest(test.TestCase): |
| |
| def testNoneWeightRaisesValueError(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) |
| with self.cached_session(): |
| with self.assertRaises(ValueError): |
| losses.softmax_cross_entropy(labels, logits, weights=None) |
| |
| @test_util.run_deprecated_v1 |
| def testAllCorrect(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) |
| loss = losses.softmax_cross_entropy(labels, logits) |
| self.assertEquals('softmax_cross_entropy_loss/value', loss.op.name) |
| self.assertAlmostEqual(loss.eval(), 0.0, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testAllWrong(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0]]) |
| |
| with self.cached_session(): |
| loss = losses.softmax_cross_entropy(labels, logits) |
| self.assertEquals(loss.op.name, 'softmax_cross_entropy_loss/value') |
| self.assertAlmostEqual(loss.eval(), 10.0, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testNonZeroLossWithPythonScalarWeight(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0]]) |
| weights = 2.3 |
| with self.cached_session(): |
| loss = losses.softmax_cross_entropy(labels, logits, weights) |
| self.assertAlmostEqual(weights * 10.0, self.evaluate(loss), 3) |
| |
| @test_util.run_deprecated_v1 |
| def testNonZeroLossWithScalarTensorWeight(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0]]) |
| weights = 2.3 |
| with self.cached_session(): |
| loss = losses.softmax_cross_entropy(labels, logits, |
| constant_op.constant(weights)) |
| self.assertAlmostEqual(weights * 10.0, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithOneDimBatchSpecificWeights(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0]]) |
| weights = constant_op.constant((1.2, 3.4, 5.6)) |
| with self.cached_session(): |
| loss = losses.softmax_cross_entropy(labels, logits, weights) |
| self.assertAlmostEqual((1.2 + 3.4 + 5.6) * 10.0 / 3.0, |
| self.evaluate(loss), 3) |
| |
| def testAllWrongAllWeightsMissing(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0]]) |
| weights = constant_op.constant([0, 0, 0], shape=[3]) |
| with self.cached_session(): |
| loss = losses.softmax_cross_entropy(labels, logits, weights) |
| self.assertAlmostEqual(0.0, self.evaluate(loss), 3) |
| |
| def testSomeWeightsMissing(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0]]) |
| weights = constant_op.constant([1.2, 0, 0], shape=[3]) |
| with self.cached_session(): |
| loss = losses.softmax_cross_entropy(labels, logits, weights) |
| self.assertAlmostEqual(12.0, self.evaluate(loss), 3) |
| |
| def testSoftmaxWithMeasurementSpecificWeightsRaisesException(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[100.0, -100.0, -100.0], |
| [-100.0, 100.0, -100.0], |
| [-100.0, -100.0, 100.0]]) |
| labels = constant_op.constant([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) |
| weights = constant_op.constant([[3, 4, 5], [2, 6, 0], [8, 0, 1]]) |
| |
| with self.assertRaises(ValueError): |
| losses.softmax_cross_entropy(labels, logits, weights=weights).eval() |
| |
| @test_util.run_deprecated_v1 |
| def testSoftmaxLabelSmoothing(self): |
| with self.cached_session(): |
| # Softmax Cross Entropy Loss is: |
| # -\sum_i p_i \log q_i |
| # where for a softmax activation |
| # \log q_i = x_i - \log \sum_j \exp x_j |
| # = x_i - x_max - \log \sum_j \exp (x_j - x_max) |
| # For our activations, [100, -100, -100] the log partion function becomes |
| # \log ( exp(0) + exp(-200) + exp(-200) ) = 0 |
| # so our log softmaxes become: [0, -200, -200] |
| # so our cross entropy loss is: |
| # -(1 - L + L/n) * 0 + 400 * L/n = 400 L/n |
| logits = constant_op.constant([[100.0, -100.0, -100.0]]) |
| labels = constant_op.constant([[1, 0, 0]]) |
| label_smoothing = 0.1 |
| loss = losses.softmax_cross_entropy( |
| labels, logits, label_smoothing=label_smoothing) |
| self.assertEquals(loss.op.name, 'softmax_cross_entropy_loss/value') |
| expected_value = 400.0 * label_smoothing / 3.0 |
| self.assertAlmostEqual(loss.eval(), expected_value, 3) |
| |
| |
| class SparseSoftmaxCrossEntropyLossTest(test.TestCase): |
| |
| def testNoneWeightRaisesValueError(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[0], [1], [2]]) |
| with self.cached_session(): |
| with self.assertRaises(ValueError): |
| losses.sparse_softmax_cross_entropy(labels, logits, weights=None) |
| |
| @test_util.run_deprecated_v1 |
| def testAllCorrectInt32Labels(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[0], [1], [2]], dtype=dtypes.int32) |
| loss = losses.sparse_softmax_cross_entropy(labels, logits) |
| self.assertEquals(loss.op.name, 'sparse_softmax_cross_entropy_loss/value') |
| self.assertAlmostEqual(loss.eval(), 0.0, 3) |
| |
| @test_util.assert_no_new_pyobjects_executing_eagerly |
| def testEagerNoMemoryLeaked(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[0], [1], [2]], dtype=dtypes.int32) |
| losses.sparse_softmax_cross_entropy(labels, logits) |
| |
| @test_util.run_deprecated_v1 |
| def testAllCorrectInt64Labels(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[0], [1], [2]], dtype=dtypes.int64) |
| loss = losses.sparse_softmax_cross_entropy(labels, logits) |
| self.assertEquals(loss.op.name, 'sparse_softmax_cross_entropy_loss/value') |
| self.assertAlmostEqual(loss.eval(), 0.0, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testAllCorrectNonColumnLabels(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([0, 1, 2]) |
| loss = losses.sparse_softmax_cross_entropy(labels, logits) |
| self.assertEquals(loss.op.name, 'sparse_softmax_cross_entropy_loss/value') |
| self.assertAlmostEqual(loss.eval(), 0.0, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testAllWrongInt32Labels(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[2], [0], [1]], dtype=dtypes.int32) |
| |
| with self.cached_session(): |
| loss = losses.sparse_softmax_cross_entropy(labels, logits) |
| self.assertEquals(loss.op.name, 'sparse_softmax_cross_entropy_loss/value') |
| self.assertAlmostEqual(loss.eval(), 10.0, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testAllWrongInt64Labels(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[2], [0], [1]], dtype=dtypes.int64) |
| |
| with self.cached_session(): |
| loss = losses.sparse_softmax_cross_entropy(labels, logits) |
| self.assertEquals(loss.op.name, 'sparse_softmax_cross_entropy_loss/value') |
| self.assertAlmostEqual(loss.eval(), 10.0, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testAllWrongNonColumnLabels(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([2, 0, 1]) |
| |
| with self.cached_session(): |
| loss = losses.sparse_softmax_cross_entropy(labels, logits) |
| self.assertEquals(loss.op.name, 'sparse_softmax_cross_entropy_loss/value') |
| self.assertAlmostEqual(loss.eval(), 10.0, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testNonZeroLossWithPythonScalarWeight(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[2], [0], [1]]) |
| weights = 2.3 |
| with self.cached_session(): |
| loss = losses.sparse_softmax_cross_entropy(labels, logits, weights) |
| self.assertAlmostEqual(weights * 10.0, self.evaluate(loss), 3) |
| |
| @test_util.run_deprecated_v1 |
| def testNonZeroLossWithScalarTensorWeight(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[2], [0], [1]]) |
| weights = 2.3 |
| with self.cached_session(): |
| loss = losses.sparse_softmax_cross_entropy(labels, logits, |
| constant_op.constant(weights)) |
| self.assertAlmostEqual(weights * 10.0, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWith1DTensorWeight(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[2], [0], [1]]) |
| weights = 2.3 |
| with self.cached_session(): |
| loss = losses.sparse_softmax_cross_entropy( |
| labels, logits, constant_op.constant((weights,))) |
| self.assertAlmostEqual(weights * 10.0, self.evaluate(loss), 3) |
| |
| @test_util.run_deprecated_v1 |
| def testNonZeroLossWithPlaceholderForWeights(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], |
| [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[2], [0], [1]]) |
| weights = array_ops.placeholder(dtypes.float32) |
| with self.cached_session() as sess: |
| loss = losses.sparse_softmax_cross_entropy(labels, logits, weights) |
| loss_val = sess.run(loss, |
| feed_dict={weights: ((1.2,), (3.4,), (5.6,))}) |
| self.assertAlmostEqual((1.2 + 3.4 + 5.6) * 10.0 / 3.0, loss_val, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testUnknownShapePlaceholderForLogitsLabelsButScalarWeights(self): |
| logits = array_ops.placeholder(dtypes.float32) |
| labels = array_ops.placeholder(dtypes.int32) |
| weights = 1.0 |
| with self.cached_session() as sess: |
| loss = losses.sparse_softmax_cross_entropy(labels, logits, weights) |
| loss_val = sess.run(loss, |
| feed_dict={ |
| logits: [[10.0, 0.0, 0.0], |
| [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]], |
| labels: [[2], [0], [1]], |
| }) |
| self.assertAlmostEqual((1.0 + 1.0 + 1.0) * 10.0 / 3.0, loss_val, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testNonZeroLossWithPlaceholderForLogitsLabelsAndWeights(self): |
| logits = array_ops.placeholder(dtypes.float32, shape=(None, 3)) |
| labels = array_ops.placeholder(dtypes.int32, shape=(None, 1)) |
| weights = array_ops.placeholder(dtypes.float32) |
| with self.cached_session() as sess: |
| loss = losses.sparse_softmax_cross_entropy(labels, logits, weights) |
| loss_val = sess.run(loss, |
| feed_dict={ |
| logits: [[10.0, 0.0, 0.0], |
| [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]], |
| labels: [[2], [0], [1]], |
| weights: ((1.2,), (3.4,), (5.6,)), |
| }) |
| self.assertAlmostEqual((1.2 + 3.4 + 5.6) * 10.0 / 3.0, loss_val, 3) |
| |
| def testNonZeroLossWithOneDimBatchSpecificWeights(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[2], [0], [1]]) |
| weights = constant_op.constant([1.2, 3.4, 5.6], shape=(3, 1)) |
| with self.cached_session(): |
| loss = losses.sparse_softmax_cross_entropy(labels, logits, weights) |
| self.assertAlmostEqual((1.2 + 3.4 + 5.6) * 10.0 / 3.0, |
| self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithColumnWeights(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[2], [0], [1]]) |
| weights = constant_op.constant([[1.2], [3.4], [5.6]]) |
| with self.cached_session(): |
| loss = losses.sparse_softmax_cross_entropy(labels, logits, weights) |
| self.assertAlmostEqual((1.2 + 3.4 + 5.6) * 10.0 / 3.0, |
| self.evaluate(loss), 3) |
| |
| def testAllWrongAllWeightsMissing(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[2], [0], [1]]) |
| weights = constant_op.constant([0, 0, 0], shape=(3, 1)) |
| with self.cached_session(): |
| loss = losses.sparse_softmax_cross_entropy(labels, logits, weights) |
| self.assertAlmostEqual(0.0, self.evaluate(loss), 3) |
| |
| def testSomeWeightsMissing(self): |
| logits = constant_op.constant([[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], |
| [0.0, 0.0, 10.0]]) |
| labels = constant_op.constant([[2], [0], [1]]) |
| weights = constant_op.constant([1.2, 0, 0], shape=(3, 1)) |
| with self.cached_session(): |
| loss = losses.sparse_softmax_cross_entropy(labels, logits, weights) |
| self.assertAlmostEqual(12.0, self.evaluate(loss), 3) |
| |
| @test_util.run_deprecated_v1 |
| def testMeasurementSpecificWeightsRaisesException(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[100.0, -100.0, -100.0], |
| [-100.0, 100.0, -100.0], |
| [-100.0, -100.0, 100.0]]) |
| labels = constant_op.constant([[0], [1], [2]]) |
| weights = constant_op.constant([[3, 4, 5], [2, 6, 0], [8, 0, 1]]) |
| |
| with self.assertRaises(ValueError): |
| losses.sparse_softmax_cross_entropy( |
| labels, logits, weights=weights).eval() |
| |
| def testInconsistentWeightSizeRaisesException(self): |
| """The weight tensor has incorrect number of elements.""" |
| with self.cached_session(): |
| logits = constant_op.constant([[100.0, -100.0, -100.0], |
| [-100.0, 100.0, -100.0], |
| [-100.0, -100.0, 100.0]]) |
| labels = constant_op.constant([[0], [1], [2]]) |
| weights = constant_op.constant([1.2, 3.4, 5.6, 7.8]) |
| |
| with self.assertRaises(ValueError): |
| losses.sparse_softmax_cross_entropy( |
| labels, logits, weights=weights).eval() |
| |
| def testInconsistentLabelSizeRaisesException(self): |
| """The label tensor has incorrect number of elements.""" |
| with self.cached_session(): |
| logits = constant_op.constant([[100.0, -100.0, -100.0], |
| [-100.0, 100.0, -100.0], |
| [-100.0, -100.0, 100.0]]) |
| labels = constant_op.constant([[0], [1], [2], [3]]) |
| weights = constant_op.constant([1.2, 3.4, 5.6]) |
| |
| with self.assertRaises(ValueError): |
| losses.sparse_softmax_cross_entropy( |
| labels, logits, weights=weights).eval() |
| |
| @test_util.run_deprecated_v1 |
| def testInconsistentWeightShapeRaisesException(self): |
| """The weight tensor has incorrect shape.""" |
| with self.cached_session(): |
| logits = constant_op.constant([[100.0, -100.0, -100.0, -100.0], |
| [-100.0, 100.0, -100.0, -100.0], |
| [-100.0, -100.0, 100.0, -100.0], |
| [-100.0, -100.0, -100.0, 100.0]]) |
| labels = constant_op.constant([[0], [1], [2], [3]]) |
| weights = constant_op.constant([[1.2, 3.4], [5.6, 7.8]]) |
| |
| with self.assertRaises(ValueError): |
| losses.sparse_softmax_cross_entropy( |
| labels, logits, weights=weights).eval() |
| |
| @test_util.run_deprecated_v1 |
| def testInconsistentLabelShapeRaisesException(self): |
| """The label tensor has incorrect shape.""" |
| with self.cached_session(): |
| logits = constant_op.constant([[100.0, -100.0, -100.0, -100.0], |
| [-100.0, 100.0, -100.0, -100.0], |
| [-100.0, -100.0, 100.0, -100.0], |
| [-100.0, -100.0, -100.0, 100.0]]) |
| labels = constant_op.constant([[0, 1], [2, 3]]) |
| weights = constant_op.constant(1.2) |
| |
| with self.assertRaisesRegexp(ValueError, 'dimension'): |
| losses.sparse_softmax_cross_entropy( |
| labels, logits, weights=weights).eval() |
| |
| |
| class SigmoidCrossEntropyLossTest(test.TestCase): |
| |
| @test_util.run_deprecated_v1 |
| def testAllCorrectSigmoid(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[100.0, -100.0, -100.0], |
| [-100.0, 100.0, -100.0], |
| [-100.0, -100.0, 100.0]]) |
| labels = constant_op.constant([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) |
| loss = losses.sigmoid_cross_entropy(labels, logits) |
| self.assertEquals(logits.dtype, loss.dtype) |
| self.assertEquals('sigmoid_cross_entropy_loss/value', loss.op.name) |
| self.assertAlmostEqual(0.0, self.evaluate(loss), 3) |
| |
| @test_util.run_deprecated_v1 |
| def testLossWithSingleDimPlaceholderForLogitsAndWeights1(self): |
| logits = array_ops.placeholder(dtypes.float32, shape=(None, 1)) |
| labels = array_ops.placeholder(dtypes.float32, shape=(None, 1)) |
| weights = array_ops.ones_like(logits, dtype=dtypes.float32) |
| |
| loss = losses.sigmoid_cross_entropy(labels, logits, weights) |
| self.assertEquals(logits.dtype, loss.dtype) |
| |
| with self.cached_session() as sess: |
| loss = sess.run(loss, |
| feed_dict={ |
| logits: np.ones((32, 1)), |
| labels: np.ones((32, 1)), |
| }) |
| self.assertAlmostEqual(0.313, loss, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testLossWithSingleDimPlaceholderForLogitsAndWeights2(self): |
| logits = array_ops.placeholder(dtypes.float32, shape=(None, 2)) |
| labels = array_ops.placeholder(dtypes.float32, shape=(None, 2)) |
| weights = array_ops.ones_like(logits, dtype=dtypes.float32) |
| |
| loss = losses.sigmoid_cross_entropy(labels, logits, weights) |
| self.assertEquals(logits.dtype, loss.dtype) |
| |
| with self.cached_session() as sess: |
| loss = sess.run(loss, |
| feed_dict={ |
| logits: np.ones((32, 2)), |
| labels: np.ones((32, 2)), |
| }) |
| self.assertAlmostEqual(0.313, loss, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testAllWrongSigmoid(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[100.0, -100.0, -100.0], |
| [-100.0, 100.0, -100.0], |
| [-100.0, -100.0, 100.0]]) |
| labels = constant_op.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0]]) |
| loss = losses.sigmoid_cross_entropy(labels, logits) |
| self.assertEquals(logits.dtype, loss.dtype) |
| self.assertEquals('sigmoid_cross_entropy_loss/value', loss.op.name) |
| self.assertAlmostEqual(loss.eval(), 600.0 / 9.0, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testAllWrongSigmoidWithMeasurementSpecificWeights(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[100.0, -100.0, -100.0], |
| [-100.0, 100.0, -100.0], |
| [-100.0, -100.0, 100.0]]) |
| labels = constant_op.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0]]) |
| weights = constant_op.constant([[3, 4, 5], [2, 6, 0], [8, 0, 1]]) |
| loss = losses.sigmoid_cross_entropy(labels, logits, weights) |
| self.assertEquals(logits.dtype, loss.dtype) |
| self.assertEquals('sigmoid_cross_entropy_loss/value', loss.op.name) |
| self.assertAlmostEqual(1700.0 / 7.0, self.evaluate(loss), 3) |
| |
| @test_util.run_deprecated_v1 |
| def testMultiCorrectSigmoid(self): |
| logits = constant_op.constant([[100.0, -100.0, 100.0], |
| [100.0, 100.0, -100.0], |
| [-100.0, 100.0, 100.0]]) |
| labels = constant_op.constant([[1, 0, 1], [1, 1, 0], [0, 1, 1]]) |
| loss = losses.sigmoid_cross_entropy(labels, logits) |
| self.assertEquals(logits.dtype, loss.dtype) |
| self.assertEquals('sigmoid_cross_entropy_loss/value', loss.op.name) |
| |
| with self.cached_session(): |
| self.assertAlmostEqual(0.0, self.evaluate(loss), 3) |
| |
| def testSigmoidFloat64(self): |
| logits = constant_op.constant(( |
| (100.0, -100.0, 100.0), |
| (100.0, -100.0, 100.0), |
| (100.0, 100.0, -100.0) |
| ), dtype=dtypes.float64) |
| labels = constant_op.constant(( |
| (1, 0, 1), (1, 1, 0), (0, 1, 1) |
| ), dtype=dtypes.int64) |
| loss = losses.sigmoid_cross_entropy(labels, logits) |
| self.assertEquals(logits.dtype, loss.dtype) |
| |
| with self.cached_session(): |
| self.assertAlmostEqual(44.444, self.evaluate(loss), 3) |
| |
| def testSigmoidNoReduction(self): |
| logits = constant_op.constant(( |
| (100.0, -100.0, 100.0), |
| (100.0, -100.0, 100.0), |
| (100.0, 100.0, -100.0))) |
| labels = constant_op.constant(((1, 0, 1), (1, 1, 0), (0, 1, 1))) |
| loss = losses.sigmoid_cross_entropy( |
| labels, logits, reduction=losses.Reduction.NONE) |
| self.assertEquals(logits.dtype, loss.dtype) |
| |
| with self.cached_session(): |
| self.assertAllClose(((0., 0., 0.), (0., 100., 100.), (100., 0., 100.)), |
| self.evaluate(loss), 3) |
| |
| @test_util.run_deprecated_v1 |
| def testSigmoidLabelSmoothingCorrect(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[100.0, -100.0, -100.0]]) |
| labels = constant_op.constant([[1, 0, 1]]) |
| # Sigmoid cross entropy loss is: |
| # max(x,0) - x*z + log(1 + exp(-abs(x))) |
| # The new labels are: |
| # z' = z * (1 - L) + 0.5 L |
| # 1 -> 1 - 0.5 L |
| # 0 -> 0.5 L |
| # here we expect: |
| # 1/3 * (100 - 100 * (1 - 0.5 L) + 0 |
| # + 0 + 100 * (0.5 L) + 0 |
| # + 0 + 100 * (1 - 0.5 L) + 0) |
| # = 1/3 * (100 + 50 L) |
| label_smoothing = 0.1 |
| loss = losses.sigmoid_cross_entropy( |
| labels, logits, label_smoothing=label_smoothing) |
| self.assertEquals(logits.dtype, loss.dtype) |
| self.assertEquals('sigmoid_cross_entropy_loss/value', loss.op.name) |
| expected_value = (100.0 + 50.0 * label_smoothing) / 3.0 |
| self.assertAlmostEqual(loss.eval(), expected_value, 3) |
| |
| @test_util.run_deprecated_v1 |
| def testSigmoidLabelSmoothingEqualsSoftmaxTwoLabel(self): |
| with self.cached_session(): |
| label_smoothing = 0.1 |
| sigmoid_logits = constant_op.constant([[100.0, -100.0, -100.0]]) |
| sigmoid_labels = constant_op.constant([[1, 0, 1]]) |
| sigmoid_loss = losses.sigmoid_cross_entropy( |
| sigmoid_labels, sigmoid_logits, label_smoothing=label_smoothing) |
| self.assertEquals(sigmoid_logits.dtype, sigmoid_loss.dtype) |
| |
| softmax_logits = constant_op.constant( |
| [[0.0, 100.0], [100.0, 0.0], [100.0, 0.0]]) |
| softmax_labels = constant_op.constant([[0, 1], [1, 0], [0, 1]]) |
| softmax_loss = losses.softmax_cross_entropy( |
| softmax_labels, softmax_logits, label_smoothing=label_smoothing) |
| self.assertAlmostEqual(sigmoid_loss.eval(), self.evaluate(softmax_loss), |
| 3) |
| |
| |
| @test_util.run_deprecated_v1 |
| class LogLossTest(test.TestCase): |
| |
| def setUp(self): |
| super(LogLossTest, self).setUp() |
| predictions = np.asarray([.9, .2, .2, .8, .4, .6]).reshape((2, 3)) |
| labels = np.asarray([1.0, 0.0, 1.0, 1.0, 0.0, 0.0]).reshape((2, 3)) |
| |
| self._np_predictions = predictions |
| self._np_labels = labels |
| |
| epsilon = 1e-7 |
| self._expected_losses = np.multiply( |
| labels, np.log(predictions + epsilon)) + np.multiply( |
| 1 - labels, np.log(1 - predictions + epsilon)) |
| |
| self._predictions = constant_op.constant(predictions) |
| self._labels = constant_op.constant(labels) |
| |
| def testValueErrorThrownWhenWeightIsNone(self): |
| with self.cached_session(): |
| with self.assertRaises(ValueError): |
| losses.log_loss(self._labels, self._labels, weights=None) |
| |
| def testAllCorrectNoLossWeight(self): |
| loss = losses.log_loss(self._labels, self._labels) |
| with self.cached_session(): |
| self.assertAlmostEqual(0.0, self.evaluate(loss), 3) |
| |
| def testAllCorrectNoLossWeightWithPlaceholder(self): |
| tf_predictions = array_ops.placeholder( |
| dtypes.float32, shape=self._np_labels.shape) |
| loss = losses.log_loss(self._labels, tf_predictions) |
| with self.cached_session(): |
| self.assertAlmostEqual( |
| 0.0, loss.eval(feed_dict={tf_predictions: self._np_labels}), 3) |
| |
| def testNonZeroLoss(self): |
| loss = losses.log_loss(self._labels, self._predictions) |
| with self.cached_session(): |
| self.assertAlmostEqual(-np.sum(self._expected_losses) / 6.0, |
| self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithPythonScalarWeight(self): |
| weights = 2.3 |
| loss = losses.log_loss(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(weights * -np.sum(self._expected_losses) / 6.0, |
| self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithScalarTensorWeight(self): |
| weights = 2.3 |
| loss = losses.log_loss(self._labels, self._predictions, |
| constant_op.constant(weights)) |
| with self.cached_session(): |
| self.assertAlmostEqual(weights * -np.sum(self._expected_losses) / 6.0, |
| self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithScalarTensorWeightAndPlaceholder(self): |
| tf_predictions = array_ops.placeholder( |
| dtypes.float32, shape=self._np_predictions.shape) |
| weights = 2.3 |
| loss = losses.log_loss(self._labels, tf_predictions, |
| constant_op.constant(weights)) |
| with self.cached_session() as sess: |
| loss = sess.run(loss, feed_dict={tf_predictions: self._np_predictions}) |
| self.assertAlmostEqual(weights * -np.sum(self._expected_losses) / 6.0, |
| loss, 3) |
| |
| def testNonZeroLossWithScalarTensorWeightAndPlaceholderWithRankOnly(self): |
| tf_predictions = array_ops.placeholder(dtypes.float32, shape=[None, None]) |
| weights = 2.3 |
| loss = losses.log_loss(self._labels, tf_predictions, |
| constant_op.constant(weights)) |
| with self.cached_session() as sess: |
| loss = sess.run(loss, feed_dict={tf_predictions: self._np_predictions}) |
| self.assertAlmostEqual(weights * -np.sum(self._expected_losses) / 6.0, |
| loss, 3) |
| |
| def testNonZeroLossWithOneDimBatchSpecificWeights(self): |
| weights = constant_op.constant((1.2, 3.4), shape=(2, 1)) |
| expected_losses = np.multiply( |
| self._expected_losses, |
| np.asarray([1.2, 1.2, 1.2, 3.4, 3.4, 3.4]).reshape((2, 3))) |
| loss = losses.log_loss(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(-np.sum(expected_losses) / 6.0, |
| self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithOneDimBatchSpecificWeightsSomeZero(self): |
| weights = constant_op.constant((1.2, 0), shape=(2, 1)) |
| expected_losses = np.multiply(self._expected_losses, |
| np.asarray([1.2, 1.2, 1.2, 0, 0, 0]).reshape( |
| (2, 3))) |
| loss = losses.log_loss(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(-np.sum(expected_losses) / 3.0, |
| self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithTwoDimBatchSpecificWeightsSomeZero(self): |
| weights = constant_op.constant([1.2, 0], shape=[2, 1]) |
| expected_losses = np.multiply(self._expected_losses, |
| np.asarray([1.2, 1.2, 1.2, 0, 0, 0]).reshape( |
| (2, 3))) |
| loss = losses.log_loss(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(-np.sum(expected_losses) / 3.0, |
| self.evaluate(loss), 3) |
| |
| def testWeightsWithSameNumDimsButWrongShapeThrowsException(self): |
| weights = constant_op.constant(np.random.normal(size=(2, 4)), shape=[2, 4]) |
| with self.cached_session(): |
| with self.assertRaises(ValueError): |
| losses.log_loss(self._labels, self._predictions, weights) |
| |
| def testNonZeroLossWithMeasurementSpecificWeights(self): |
| weights = np.array([3, 6, 5, 0, 4, 2]).reshape((2, 3)) |
| expected_losses = np.multiply(self._expected_losses, weights) |
| |
| loss = losses.log_loss( |
| self._labels, |
| self._predictions, |
| constant_op.constant( |
| weights, shape=(2, 3))) |
| with self.cached_session(): |
| self.assertAlmostEqual(-np.sum(expected_losses) / 5.0, |
| self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithMeasurementSpecificWeightsWithPlaceholder(self): |
| weights = np.array([3, 6, 5, 0, 4, 2]).reshape((2, 3)) |
| expected_losses = np.multiply(self._expected_losses, weights) |
| |
| tf_predictions = array_ops.placeholder(dtypes.float32, shape=[2, 3]) |
| loss = losses.log_loss( |
| self._labels, |
| tf_predictions, |
| constant_op.constant( |
| weights, shape=(2, 3))) |
| |
| with self.cached_session() as sess: |
| loss = sess.run(loss, feed_dict={tf_predictions: self._np_predictions}) |
| self.assertAlmostEqual(-np.sum(expected_losses) / 5.0, loss, 3) |
| |
| def testNonZeroLossWithSampleSpecificWeightsMostZero(self): |
| weights = np.array([0, 0, 0, 0, 0, 2]).reshape((2, 3)) |
| expected_losses = np.multiply(self._expected_losses, weights) |
| |
| loss = losses.log_loss( |
| self._labels, |
| self._predictions, |
| constant_op.constant( |
| weights, shape=(2, 3))) |
| with self.cached_session(): |
| self.assertAlmostEqual(-np.sum(expected_losses), self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithSampleSpecificWeightsMostZeroWithPlaceholder(self): |
| weights = np.array([0, 0, 0, 0, 0, 2]).reshape((2, 3)) |
| expected_losses = np.multiply(self._expected_losses, weights) |
| |
| tf_predictions = array_ops.placeholder(dtypes.float32, shape=[2, 3]) |
| tf_weights = constant_op.constant(weights, shape=(2, 3)) |
| loss = losses.log_loss(self._labels, tf_predictions, tf_weights) |
| |
| with self.cached_session() as sess: |
| loss = sess.run(loss, feed_dict={tf_predictions: self._np_predictions}) |
| self.assertAlmostEqual(-np.sum(expected_losses), loss, 3) |
| |
| def testLossWithSampleSpecificWeightsAllZero(self): |
| tf_weights = array_ops.zeros(shape=(2, 3)) |
| loss = losses.log_loss(self._labels, self._predictions, tf_weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(0.0, self.evaluate(loss), 3) |
| |
| |
| class HingeLossTest(test.TestCase): |
| |
| def testIncompatibleShapes(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[-1.0], [2.1]]) |
| labels = constant_op.constant([0.0, 1.0]) |
| with self.assertRaises(ValueError): |
| _ = losses.hinge_loss(labels, logits).eval() |
| |
| @test_util.run_deprecated_v1 |
| def testAllOutsideMargin(self): |
| with self.cached_session(): |
| logits = constant_op.constant([1.2, -1.4, -1.0, 2.1]) |
| labels = constant_op.constant([1.0, 0.0, 0.0, 1.0]) |
| loss = losses.hinge_loss(labels, logits) |
| self.assertAllClose(loss.eval(), 0.0, atol=1e-3) |
| |
| @test_util.run_deprecated_v1 |
| def testSomeInsideMargin(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[-0.7], [-1.4], [1.4], [0.6]]) |
| labels = constant_op.constant([[0.0], [0.0], [1.0], [1.0]]) |
| loss = losses.hinge_loss(labels, logits) |
| # Examples 1 and 4 are on the correct side of the hyperplane but within |
| # the margin so they incur some (small) loss. |
| self.assertAllClose(loss.eval(), 0.175, atol=1e-3) |
| |
| @test_util.run_deprecated_v1 |
| def testSomeMisclassified(self): |
| with self.cached_session(): |
| logits = constant_op.constant([[[1.2], [0.4], [-1.0], [-1.1]]]) |
| labels = constant_op.constant([[[1.0], [0.0], [0.0], [1.0]]]) |
| loss = losses.hinge_loss(labels, logits) |
| # Examples 2 and 4 are on the wrong side of the hyperplane so they incur |
| # some (fairly large) loss. |
| self.assertAllClose(loss.eval(), 0.875, atol=1e-3) |
| |
| |
| class HuberLossTest(test.TestCase): |
| |
| def testIncompatibleShapes(self): |
| with self.cached_session(): |
| predictions = constant_op.constant([[-1.0], [2.1]]) |
| labels = constant_op.constant([0.0, 1.0]) |
| with self.assertRaises(ValueError): |
| _ = losses.huber_loss(labels, predictions).eval() |
| |
| @test_util.run_deprecated_v1 |
| def testAllQuadratic(self): |
| with self.cached_session(): |
| predictions = constant_op.constant([1.5, -1.4, -1.0, 0.0]) |
| labels = constant_op.constant([1.0, -1.0, 0.0, 0.5]) |
| loss = losses.huber_loss(labels, predictions) |
| self.assertAllClose(loss.eval(), |
| 0.5 * (0.25 + 0.16 + 1.0 + 0.25) / 4., atol=1e-5) |
| |
| @test_util.run_deprecated_v1 |
| def testAllLinear(self): |
| with self.cached_session(): |
| predictions = constant_op.constant([1.5, -1.4, -1.0, 0.0]) |
| labels = constant_op.constant([0.0, 1.0, 0.0, 1.5]) |
| loss = losses.huber_loss(labels, predictions) |
| self.assertAllClose(loss.eval(), |
| (1.5 + 2.4 + 1.0 + 1.5) / 4. - 0.5, atol=1e-5) |
| |
| @test_util.run_deprecated_v1 |
| def testMixedQuadraticLinear(self): |
| with self.cached_session(): |
| predictions = constant_op.constant([[1.5, -1.4, -1.0, 0.0], |
| [1.5, -1.4, -1.0, 0.0]]) |
| labels = constant_op.constant([[1.0, -1.0, 0.0, 0.5], |
| [0.0, 1.0, 0.0, 1.5]]) |
| loss = losses.huber_loss(labels, predictions) |
| quadratic = 0.5 * (0.25 + 0.16 + 1.0 + 0.25) / 4. |
| linear = (1.5 + 2.4 + 1.0 + 1.5) / 4. - 0.5 |
| expected_loss = (quadratic + linear) / 2. |
| self.assertAllClose(loss.eval(), expected_loss, atol=1e-5) |
| |
| def testAllQuadraticDelta(self): |
| with self.cached_session(): |
| delta = 0.5 |
| predictions = constant_op.constant([1.5, -1.4, -0.5, 0.0]) |
| labels = constant_op.constant([1.0, -1.0, 0.0, 0.5]) |
| expected = 0.5 * np.array([0.5**2, 0.4**2, 0.5**2, 0.5**2]).mean() |
| loss = losses.huber_loss(labels, predictions, delta=delta) |
| self.assertAllClose(expected, self.evaluate(loss), atol=1e-5) |
| |
| def testAllLinearDelta(self): |
| delta = 0.5 |
| predictions = constant_op.constant([1.5, -1.4, -1.0, 0.0]) |
| labels = constant_op.constant([0.0, 1.0, 0.0, 1.5]) |
| expected = delta * np.array([1.5, 2.4, 1.0, 1.5]).mean() |
| expected -= 0.5 * delta**2 |
| loss = losses.huber_loss(labels, predictions, delta=delta) |
| with self.cached_session(): |
| self.assertAllClose(expected, self.evaluate(loss), atol=1e-5) |
| |
| |
| @test_util.run_deprecated_v1 |
| class MeanSquaredErrorTest(test.TestCase): |
| |
| def setUp(self): |
| super(MeanSquaredErrorTest, self).setUp() |
| self._predictions = constant_op.constant([4, 8, 12, 8, 1, 3], shape=(2, 3)) |
| self._labels = constant_op.constant([1, 9, 2, -5, -2, 6], shape=(2, 3)) |
| |
| def testValueErrorThrownWhenWeightIsNone(self): |
| with self.cached_session(): |
| with self.assertRaises(ValueError): |
| losses.mean_squared_error( |
| self._predictions, self._predictions, weights=None) |
| |
| @test_util.run_deprecated_v1 |
| def testScalar(self): |
| with self.cached_session(): |
| self.assertEqual( |
| 0.0, |
| losses.mean_squared_error(predictions=constant_op.constant(0), |
| labels=constant_op.constant(0)).eval()) |
| |
| @test_util.run_deprecated_v1 |
| def testAllCorrectNoLossWeight(self): |
| loss = losses.mean_squared_error(self._predictions, self._predictions) |
| with self.cached_session(): |
| self.assertAlmostEqual(0.0, self.evaluate(loss), 3) |
| |
| @test_util.run_deprecated_v1 |
| def testNonZeroLoss(self): |
| loss = losses.mean_squared_error(self._labels, self._predictions) |
| with self.cached_session(): |
| self.assertAlmostEqual(49.5, self.evaluate(loss), 3) |
| |
| @test_util.run_deprecated_v1 |
| def testNonZeroLossWithPythonScalarWeight(self): |
| weights = 2.3 |
| loss = losses.mean_squared_error(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(49.5 * weights, self.evaluate(loss), 3) |
| |
| @test_util.run_deprecated_v1 |
| def testNonZeroLossWithScalarTensorWeight(self): |
| weights = 2.3 |
| loss = losses.mean_squared_error(self._labels, self._predictions, |
| constant_op.constant(weights)) |
| with self.cached_session(): |
| self.assertAlmostEqual(49.5 * weights, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithOneDimBatchSpecificWeights(self): |
| weights = constant_op.constant([1.2, 3.4], shape=(2, 1)) |
| loss = losses.mean_squared_error(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(767.8 / 6.0, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithTwoDimBatchSpecificWeights(self): |
| weights = constant_op.constant([1.2, 3.4], shape=[2, 1]) |
| loss = losses.mean_squared_error(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(767.8 / 6.0, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithSampleSpecificWeights(self): |
| weights = constant_op.constant([3, 6, 5, 0, 4, 2], shape=[2, 3]) |
| loss = losses.mean_squared_error(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(587 / 5.0, self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithSampleSpecificWeightsMostZero(self): |
| weights = constant_op.constant([0, 0, 0, 0, 0, 2], shape=[2, 3]) |
| loss = losses.mean_squared_error(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(18.0, self.evaluate(loss), 3) |
| |
| def testLossWithSampleSpecificWeightsAllZero(self): |
| weights = array_ops.zeros((2, 3)) |
| loss = losses.mean_squared_error(self._labels, self._predictions, weights) |
| with self.cached_session(): |
| self.assertAlmostEqual(0.0, self.evaluate(loss), 3) |
| |
| |
| @test_util.run_deprecated_v1 |
| class MeanPairwiseSquaredErrorTest(test.TestCase): |
| |
| def setUp(self): |
| super(MeanPairwiseSquaredErrorTest, self).setUp() |
| self._predictions = np.array([[4, 8, 12], [8, 1, 3]]) |
| self._labels = np.array([[1, 9, 2], [-5, -5, 7]]) |
| |
| batch_size, dims = self._labels.shape |
| |
| # Compute the expected loss 'manually'. |
| total = np.zeros((batch_size,)) |
| for b in range(batch_size): |
| for i in range(dims - 1): |
| for j in range(i + 1, dims): |
| x = self._predictions[b, i].item() - self._predictions[b, j].item() |
| y = self._labels[b, i].item() - self._labels[b, j].item() |
| diff = (x - y) |
| total[b] += (diff * diff) |
| |
| self._expected_losses = np.divide(total, 3.0) |
| |
| def testValueErrorThrownWhenWeightIsNone(self): |
| with self.cached_session(): |
| with self.assertRaises(ValueError): |
| losses.mean_pairwise_squared_error( |
| predictions=constant_op.constant(self._labels), |
| labels=constant_op.constant(self._labels), |
| weights=None) |
| |
| def _test_valid_weights( |
| self, labels, predictions, expected_loss, weights=1.0): |
| with self.cached_session(): |
| static_inputs_op = losses.mean_pairwise_squared_error( |
| predictions=predictions, labels=labels, weights=weights) |
| self.assertAlmostEqual( |
| expected_loss, self.evaluate(static_inputs_op), places=3) |
| |
| predictions_placeholder = array_ops.placeholder( |
| dtypes.float32, shape=np.asarray(predictions.shape)) |
| labels_placeholder = array_ops.placeholder( |
| dtypes.int32, shape=np.asarray(labels.shape)) |
| weights_placeholder = array_ops.placeholder( |
| dtypes.float32, shape=np.asarray(weights).shape) |
| dynamic_inputs_op = losses.mean_pairwise_squared_error( |
| predictions=predictions_placeholder, |
| labels=labels_placeholder, |
| weights=weights_placeholder) |
| feed_dict = { |
| predictions_placeholder: predictions, |
| labels_placeholder: labels, |
| weights_placeholder: weights, |
| } |
| self.assertAlmostEqual( |
| expected_loss, dynamic_inputs_op.eval(feed_dict=feed_dict), places=3) |
| |
| def testAllCorrectNoLossWeight(self): |
| self._test_valid_weights( |
| self._labels, self._labels, expected_loss=0.0) |
| |
| def testNonZeroLoss(self): |
| self._test_valid_weights( |
| self._labels, self._predictions, |
| expected_loss=np.sum(self._expected_losses)) |
| |
| def testGradientWithZeroWeight(self): |
| with ops.Graph().as_default(): |
| random_seed.set_random_seed(0) |
| |
| inputs = array_ops.ones((2, 3)) |
| weights = variable_scope.get_variable( |
| 'weights', |
| shape=[3, 4], |
| initializer=init_ops.truncated_normal_initializer()) |
| predictions = math_ops.matmul(inputs, weights) |
| |
| optimizer = momentum_lib.MomentumOptimizer( |
| learning_rate=0.001, momentum=0.9) |
| loss = losses.mean_pairwise_squared_error(predictions, predictions, 0) |
| |
| gradients_to_variables = optimizer.compute_gradients(loss) |
| |
| init_op = variables.global_variables_initializer() |
| |
| with self.cached_session() as sess: |
| self.evaluate(init_op) |
| for grad, _ in gradients_to_variables: |
| np_grad = self.evaluate(grad) |
| self.assertFalse(np.isnan(np_grad).any()) |
| |
| def testNonZeroLossWithPythonScalarWeight(self): |
| weight = 2.3 |
| self._test_valid_weights( |
| self._labels, self._predictions, |
| expected_loss=weight * np.sum(self._expected_losses), |
| weights=weight) |
| |
| def testNonZeroLossWithScalarTensorWeight(self): |
| weights = 2.3 |
| loss = losses.mean_pairwise_squared_error( |
| predictions=constant_op.constant(self._predictions), |
| labels=constant_op.constant(self._labels), |
| weights=constant_op.constant(weights)) |
| with self.cached_session(): |
| self.assertAlmostEqual(weights * np.sum(self._expected_losses), |
| self.evaluate(loss), 3) |
| |
| def testNonZeroLossWithScalarZeroWeight(self): |
| self._test_valid_weights( |
| self._labels, self._predictions, expected_loss=0.0, weights=0.0) |
| |
| def test3d(self): |
| labels = np.array([ |
| [[1, 9, 2], [12, 11, 10], [9, 8, 7]], |
| [[-5, -5, 7], [6, 5, 4], [3, 2, 1]], |
| ]) |
| predictions = np.array([ |
| [[4, 8, 12], [1, 2, 3], [4, 5, 6]], |
| [[8, 1, 3], [7, 8, 9], [10, 11, 12]], |
| ]) |
| self._test_valid_weights(labels, predictions, expected_loss=137.5) |
| |
| def test3dWeightedScalar(self): |
| labels = np.array([ |
| [[1, 9, 2], [12, 11, 10], [9, 8, 7]], |
| [[-5, -5, 7], [6, 5, 4], [3, 2, 1]], |
| ]) |
| predictions = np.array([ |
| [[4, 8, 12], [1, 2, 3], [4, 5, 6]], |
| [[8, 1, 3], [7, 8, 9], [10, 11, 12]], |
| ]) |
| weight = 3.0 |
| self._test_valid_weights( |
| labels, predictions, expected_loss=weight * 137.5, weights=weight) |
| |
| def _test_invalid_weights( |
| self, labels, predictions, weights=1.0): |
| expected_error_msg = 'weights can not be broadcast to values' |
| |
| # Static check. |
| with self.assertRaisesRegexp(ValueError, expected_error_msg): |
| losses.mean_pairwise_squared_error( |
| predictions=predictions, labels=labels, weights=weights) |
| |
| # Dynamic check. |
| predictions_placeholder = array_ops.placeholder(dtypes.float32) |
| labels_placeholder = array_ops.placeholder(dtypes.int32) |
| weights_placeholder = array_ops.placeholder(dtypes.float32) |
| dynamic_inputs_op = losses.mean_pairwise_squared_error( |
| predictions=predictions_placeholder, |
| labels=labels_placeholder, |
| weights=weights_placeholder) |
| with self.cached_session(): |
| with self.assertRaisesRegexp(errors_impl.OpError, expected_error_msg): |
| dynamic_inputs_op.eval(feed_dict={ |
| predictions_placeholder: predictions, |
| labels_placeholder: labels, |
| weights_placeholder: weights, |
| }) |
| |
| def testInvalid3dWeighted2x0(self): |
| labels = np.array([ |
| [[1, 9, 2], [12, 11, 10], [9, 8, 7]], |
| [[-5, -5, 7], [6, 5, 4], [3, 2, 1]], |
| ]) |
| predictions = np.array([ |
| [[4, 8, 12], [1, 2, 3], [4, 5, 6]], |
| [[8, 1, 3], [7, 8, 9], [10, 11, 12]], |
| ]) |
| self._test_invalid_weights( |
| labels, predictions, weights=np.asarray((1.2, 3.4))) |
| |
| def test3dWeighted2x3x3(self): |
| labels = np.array([ |
| [[1, 9, 2], [12, 11, 10], [9, 8, 7]], |
| [[-5, -5, 7], [6, 5, 4], [3, 2, 1]], |
| ]) |
| predictions = np.array([ |
| [[4, 8, 12], [1, 2, 3], [4, 5, 6]], |
| [[8, 1, 3], [7, 8, 9], [10, 11, 12]], |
| ]) |
| self._test_valid_weights( |
| # TODO(ptucker): This doesn't look right. |
| labels, |
| predictions, |
| expected_loss=9 * 137.5, |
| weights=np.ones((2, 3, 3))) |
| |
| def testLossWithAllZeroBatchSpecificWeights(self): |
| self._test_valid_weights( |
| self._labels, self._predictions, expected_loss=0.0, |
| weights=np.zeros((2, 1))) |
| |
| def testLossIsAssociativeAcrossBatchElements(self): |
| with ops.Graph().as_default(): |
| random_seed.set_random_seed(0) |
| |
| height = 3 |
| width = 4 |
| shape = (1, height, width, 1) |
| |
| labels0 = random_ops.random_uniform( |
| shape, minval=0, maxval=1, dtype=dtypes.float32) |
| predictions0 = random_ops.random_uniform( |
| shape, minval=0, maxval=1, dtype=dtypes.float32) |
| |
| labels1 = random_ops.random_uniform( |
| shape, minval=0, maxval=1, dtype=dtypes.float32) |
| predictions1 = random_ops.random_uniform( |
| shape, minval=0, maxval=1, dtype=dtypes.float32) |
| |
| loss0 = losses.mean_pairwise_squared_error( |
| labels=labels0, |
| predictions=predictions0) |
| loss1 = losses.mean_pairwise_squared_error( |
| labels=labels1, |
| predictions=predictions1) |
| loss0_1 = losses.mean_pairwise_squared_error( |
| labels=array_ops.concat([labels0, labels1], 0), |
| predictions=array_ops.concat([predictions0, predictions1], 0)) |
| |
| with self.cached_session() as session: |
| loss0, loss1, loss0_1 = session.run([loss0, loss1, loss0_1]) |
| |
| self.assertTrue(loss0 > 0) |
| self.assertTrue(loss1 > 0) |
| self.assertAlmostEqual(loss0 + loss1, loss0_1, 5) |
| |
| |
| @test_util.run_deprecated_v1 |
| class CosineDistanceLossTest(test.TestCase): |
| |
| def setUp(self): |
| super(CosineDistanceLossTest, self).setUp() |
| self._predictions = np.asarray([ |
| [1, 0, 0], # Batch 1 |
| [0, 0, -1], |
| [1, 0, 0], # Batch 2 |
| [1, 0, 0], |
| [0, 0, -1], # Batch 3 |
| [1, 0, 0] |
| ]).reshape((3, 2, 3)) |
| |
| self._labels = np.asarray([[1, 0, 0], [0, 0, 1], [0, 1, 0], [1, 0, 0], |
| [0, 0, 1], [0, 1, 0]]).reshape((3, 2, 3)) |
| |
| def testValueErrorThrownWhenWeightIsNone(self): |
| with self.cached_session(): |
| with self.assertRaises(ValueError): |
| losses.cosine_distance( |
| predictions=constant_op.constant(self._labels), |
| labels=constant_op.constant(self._labels), |
| dim=2, |
| weights=None) |
| |
| def testAllCorrectNoWeights(self): |
| loss = losses.cosine_distance( |
| predictions=constant_op.constant(self._labels), |
| labels=constant_op.constant(self._labels), |
| dim=2) |
| with self.cached_session(): |
| self.assertAlmostEqual(0, self.evaluate(loss), 5) |
| |
| def testPartiallyCorrectWithIntegerValues(self): |
| loss = losses.cosine_distance( |
| predictions=constant_op.constant(self._predictions), |
| labels=constant_op.constant(self._labels), |
| dim=2) |
| with self.cached_session(): |
| self.assertAlmostEqual(1, self.evaluate(loss), 5) |
| |
| def testPartiallyCorrectFloatingPointValues(self): |
| predictions = np.matrix( |
| ('0.819031913261206 0.567041924552012 0.087465312324590;' |
| '-0.665139432070255 -0.739487441769973 -0.103671883216994;' |
| '0.707106781186548 -0.707106781186548 0')) |
| labels = np.matrix(('0.819031913261206 0.567041924552012 0.087465312324590;' |
| '0.665139432070255 0.739487441769973 0.103671883216994;' |
| '0.707106781186548 0.707106781186548 0')) |
| |
| tf_preds = constant_op.constant( |
| predictions, shape=(3, 1, 3), dtype=dtypes.float32) |
| tf_labels = constant_op.constant( |
| labels, shape=(3, 1, 3), dtype=dtypes.float32) |
| loss = losses.cosine_distance(tf_labels, tf_preds, dim=2) |
| |
| with self.cached_session(): |
| self.assertAlmostEqual(1.0, self.evaluate(loss), 5) |
| |
| def testSampleSpecificWeights(self): |
| loss = losses.cosine_distance( |
| predictions=constant_op.constant(self._predictions), |
| labels=constant_op.constant(self._labels), |
| dim=2, |
| weights=np.asarray((1, 0, 0)).reshape((3, 1, 1))) |
| with self.cached_session(): |
| self.assertEqual(1.0, self.evaluate(loss)) |
| |
| def testMeasurementSpecificWeights(self): |
| loss = losses.cosine_distance( |
| predictions=constant_op.constant(self._predictions), |
| labels=constant_op.constant(self._labels), |
| dim=2, |
| weights=constant_op.constant( |
| [1, 0, 0, 1, 1, 1], shape=(3, 2, 1))) |
| with self.cached_session(): |
| self.assertEqual(3.0 / 4.0, self.evaluate(loss)) |
| |
| def testMeasurementSpecificWeightsWithPlaceholderWithShape(self): |
| tf_predictions = array_ops.placeholder( |
| dtypes.float32, shape=self._labels.shape) |
| loss = losses.cosine_distance( |
| predictions=tf_predictions, |
| labels=constant_op.constant(self._labels), |
| dim=2, |
| weights=constant_op.constant( |
| [1, 0, 0, 1, 1, 1], shape=(3, 2, 1))) |
| with self.cached_session() as sess: |
| loss = sess.run(loss, feed_dict={tf_predictions: self._predictions}) |
| self.assertEqual(3.0 / 4.0, loss) |
| |
| def testZeroLossWhenAllSampleSpecificWeightsAreZero(self): |
| loss = losses.cosine_distance( |
| predictions=constant_op.constant(self._predictions), |
| labels=constant_op.constant(self._labels), |
| dim=2, |
| weights=array_ops.zeros((3, 1, 1))) |
| with self.cached_session(): |
| self.assertEqual(0, self.evaluate(loss)) |
| |
| def testZeroLossWhenAllMeasurementSpecificWeightsAreZero(self): |
| loss = losses.cosine_distance( |
| predictions=constant_op.constant(self._predictions), |
| labels=constant_op.constant(self._labels), |
| dim=2, |
| weights=array_ops.zeros((3, 2, 1))) |
| with self.cached_session(): |
| self.assertEqual(0, self.evaluate(loss)) |
| |
| |
| class AddLossTest(test.TestCase): |
| |
| def testNoCollectLossesBatch2(self): |
| logits = constant_op.constant([[1.2, 0.4, -1.0, -1.1]] * 2) |
| labels = constant_op.constant([[1.0, 0.0, 0.0, 1.0]] * 2) |
| self.assertFalse(util.get_losses()) |
| losses.absolute_difference(logits, labels, loss_collection=None) |
| losses.log_loss(logits, labels, loss_collection=None) |
| losses.mean_squared_error(logits, labels, loss_collection=None) |
| losses.sigmoid_cross_entropy(logits, labels, loss_collection=None) |
| losses.softmax_cross_entropy(logits, labels, loss_collection=None) |
| self.assertFalse(util.get_losses()) |
| |
| |
| class ComputeWeightedLossTest(test.TestCase): |
| |
| def setUp(self): |
| super(ComputeWeightedLossTest, self).setUp() |
| self._shape = (3, 2, 4) |
| raw_losses = np.zeros(self._shape) |
| next_loss = 0.0 |
| for i in range(self._shape[0]): |
| for j in range(self._shape[1]): |
| for k in range(self._shape[2]): |
| raw_losses[i][j][k] = next_loss |
| next_loss += 1.0 |
| raw_losses.setflags(write=False) |
| self._raw_losses = raw_losses |
| |
| def testUnweighted(self): |
| for reduction in losses.Reduction.all(): |
| with ops.Graph().as_default() as g: |
| self.assertEqual(0, len(util.get_losses())) |
| raw_losses = self._raw_losses |
| unweighted_losses = ( |
| losses.compute_weighted_loss(raw_losses, reduction=reduction), |
| losses.compute_weighted_loss( |
| raw_losses, weights=np.ones((1, 1, 1)), reduction=reduction), |
| losses.compute_weighted_loss( |
| raw_losses, weights=np.ones((1, 1, 4)), reduction=reduction), |
| losses.compute_weighted_loss( |
| raw_losses, weights=np.ones((1, 2, 1)), reduction=reduction), |
| losses.compute_weighted_loss( |
| raw_losses, weights=np.ones((1, 2, 4)), reduction=reduction), |
| losses.compute_weighted_loss( |
| raw_losses, weights=np.ones((3, 1, 1)), reduction=reduction), |
| losses.compute_weighted_loss( |
| raw_losses, weights=np.ones((3, 1, 4)), reduction=reduction), |
| losses.compute_weighted_loss( |
| raw_losses, weights=np.ones((3, 2, 1)), reduction=reduction), |
| losses.compute_weighted_loss( |
| raw_losses, weights=np.ones(self._shape), reduction=reduction) |
| ) |
| self.assertEqual(9, len(util.get_losses())) |
| with self.session(g): |
| for unweighted_loss in unweighted_losses: |
| if reduction == losses.Reduction.NONE: |
| self.assertAllClose(self._raw_losses, |
| self.evaluate(unweighted_loss)) |
| elif reduction == losses.Reduction.SUM: |
| self.assertAllClose( |
| np.sum(self._raw_losses), self.evaluate(unweighted_loss)) |
| else: |
| # reduction one of MEAN, SUM_OVER_NONZERO_WEIGHTS, |
| # SUM_BY_NONZERO_WEIGHTS or SUM_OVER_BATCH_SIZE. |
| self.assertAllClose( |
| np.mean(self._raw_losses), self.evaluate(unweighted_loss)) |
| |
| def testUnweightedFromPlaceholder(self): |
| for reduction in losses.Reduction.all(): |
| with ops.Graph().as_default() as g: |
| self.assertEqual(0, len(util.get_losses())) |
| raw_losses = array_ops.placeholder(dtype=dtypes.float32) |
| feed_dict = {raw_losses: self._raw_losses} |
| unweighted_losses = ( |
| losses.compute_weighted_loss(raw_losses, reduction=reduction), |
| losses.compute_weighted_loss( |
| raw_losses, weights=np.ones((1, 1, 1)), reduction=reduction), |
| losses.compute_weighted_loss( |
| raw_losses, weights=np.ones((1, 1, 4)), reduction=reduction), |
| ) |
| self.assertEqual(3, len(util.get_losses())) |
| with self.session(g): |
| for unweighted_loss in unweighted_losses: |
| if reduction == losses.Reduction.NONE: |
| self.assertAllClose( |
| self._raw_losses, unweighted_loss.eval(feed_dict)) |
| elif reduction == losses.Reduction.SUM: |
| self.assertAllClose( |
| np.sum(self._raw_losses), unweighted_loss.eval(feed_dict)) |
| else: |
| # reduction one of MEAN, SUM_OVER_NONZERO_WEIGHTS, |
| # SUM_BY_NONZERO_WEIGHTS or SUM_OVER_BATCH_SIZE. |
| self.assertAllClose( |
| np.mean(self._raw_losses), unweighted_loss.eval(feed_dict)) |
| |
| def testScalarWeight(self): |
| with ops.Graph().as_default(): |
| self.assertEqual(0, len(util.get_losses())) |
| weight = 17.0 |
| weighted_loss = losses.compute_weighted_loss( |
| self._raw_losses, weights=weight) |
| self.assertEqual(1, len(util.get_losses())) |
| with self.cached_session(): |
| self.assertAllClose( |
| np.mean(weight * self._raw_losses), self.evaluate(weighted_loss)) |
| |
| def _test_invalid_weights(self, weights): |
| with ops.Graph().as_default(): |
| self.assertEqual(0, len(util.get_losses())) |
| expected_error_msg = 'weights can not be broadcast to values' |
| |
| # Static check. |
| with self.assertRaisesRegexp(ValueError, expected_error_msg): |
| losses.compute_weighted_loss(self._raw_losses, weights=weights) |
| |
| # Dynamic check. |
| weights_placeholder = array_ops.placeholder(dtypes.float32) |
| weighted_loss = losses.compute_weighted_loss( |
| self._raw_losses, weights=weights_placeholder) |
| self.assertEqual(1, len(util.get_losses())) |
| with self.cached_session(): |
| with self.assertRaisesRegexp(errors_impl.OpError, expected_error_msg): |
| weighted_loss.eval(feed_dict={weights_placeholder: weights}) |
| |
| def testInvalidWeightTooManyDims(self): |
| self._test_invalid_weights(np.zeros(shape=(2, 2, 2, 2))) |
| |
| def testInvalidWeightMismatchedDim(self): |
| with ops.Graph().as_default(): |
| raw_losses = array_ops.reshape(self._raw_losses, shape=(3, 2, 4, 1)) |
| weights = np.ones(shape=(3, 2, 4, 2)) |
| expected_error_msg = 'weights can not be broadcast to values' |
| self.assertEqual(0, len(util.get_losses())) |
| |
| # Static check. |
| with self.assertRaisesRegexp(ValueError, expected_error_msg): |
| losses.compute_weighted_loss(raw_losses, weights=weights) |
| |
| # Dynamic check. |
| weights_placeholder = array_ops.placeholder(dtypes.float32) |
| weighted_loss = losses.compute_weighted_loss( |
| raw_losses, weights=weights_placeholder) |
| self.assertEqual(1, len(util.get_losses())) |
| with self.cached_session(): |
| with self.assertRaisesRegexp(errors_impl.OpError, expected_error_msg): |
| weighted_loss.eval(feed_dict={weights_placeholder: weights}) |
| |
| def testInvalid3Weight(self): |
| self._test_invalid_weights((17.0, 5.0, 2.0)) |
| |
| def testInvalid3x1Weight(self): |
| self._test_invalid_weights(((17.0,), (5.0,), (2.0,),)) |
| |
| def testInvalid3x2Weight(self): |
| self._test_invalid_weights(( |
| (17.0, 3.0), |
| (5.0, 31.0), |
| (2.0, 7.0),)) |
| |
| def testInvalid1x2Weight(self): |
| self._test_invalid_weights((17.0, 3.0,),) |
| |
| def testInvalidScalar1DWeight(self): |
| self._test_invalid_weights((17.0,),) |
| |
| def _test_valid_weights(self, weights): |
| for reduction in losses.Reduction.all(): |
| with ops.Graph().as_default() as g: |
| self.assertEqual(0, len(util.get_losses())) |
| weighted_loss = losses.compute_weighted_loss( |
| self._raw_losses, weights=weights, reduction=reduction) |
| self.assertEqual(1, len(util.get_losses())) |
| with self.session(g): |
| weighted_losses = weights * self._raw_losses |
| weighted_sum = np.sum(weighted_losses) |
| if reduction == losses.Reduction.NONE: |
| self.assertAllClose(weighted_losses, self.evaluate(weighted_loss)) |
| elif reduction == losses.Reduction.SUM: |
| self.assertAllClose(weighted_sum, self.evaluate(weighted_loss)) |
| else: |
| broadcast_weights = weights * np.ones_like(self._raw_losses) |
| if reduction == losses.Reduction.MEAN: |
| self.assertAllClose(weighted_sum / np.sum(broadcast_weights), |
| self.evaluate(weighted_loss)) |
| elif (reduction == losses.Reduction.SUM_OVER_NONZERO_WEIGHTS or |
| reduction == losses.Reduction.SUM_BY_NONZERO_WEIGHTS): |
| self.assertAllClose( |
| weighted_sum / np.count_nonzero(broadcast_weights), |
| self.evaluate(weighted_loss)) |
| elif reduction == losses.Reduction.SUM_OVER_BATCH_SIZE: |
| self.assertAllClose(weighted_sum / self._raw_losses.size, |
| self.evaluate(weighted_loss)) |
| |
| def test1x1x1Weight(self): |
| self._test_valid_weights((((17.0,),),)) |
| |
| def test1x2x1Weight(self): |
| self._test_valid_weights((((17.0,), (3.0,),),)) |
| |
| def test1x1x4Weight(self): |
| self._test_valid_weights((((17.0, 0.0, 2.0, 5.0),),)) |
| |
| def test3x1x1Weight(self): |
| self._test_valid_weights((((17.0,),), ((5.0,),), ((2.0,),),)) |
| |
| def test3x2x1Weight(self): |
| self._test_valid_weights(( |
| ((17.0,), (3.0,)), |
| ((5.0,), (31.0,)), |
| ((2.0,), (7.0,)), |
| )) |
| |
| def test3x1x4Weight(self): |
| self._test_valid_weights(( |
| ((17.0, 0.0, 2.0, 5.0),), |
| ((5.0, 31.0, 17.0, 5.0),), |
| ((7.0, 3.0, 11.0, 5.0),), |
| )) |
| |
| def test1x2x4Weight(self): |
| self._test_valid_weights((( |
| (17.0, 0.0, 2.0, 5.0), |
| (3.0, 13.0, 11.0, 2.0), |
| ),)) |
| |
| def test3x2x4Weight(self): |
| self._test_valid_weights(( |
| ((17.0, 0.0, 2.0, 5.0), (3.0, 13.0, 11.0, 2.0),), |
| ((5.0, 31.0, 17.0, 5.0), (13.0, 3.0, 0.0, 11.0),), |
| ((0.0, 3.0, 11.0, 5.0), (13.0, 11.0, 1.0, 7.0),), |
| )) |
| |
| |
| if __name__ == '__main__': |
| test.main() |
