コード例 #1
0
    def test_enter_exit_threadsafe(self):
        # This test ensures reporter.__enter__ correctly stores the reporter
        # in the thread-local storage.

        def thread_func(reporter, record):
            with reporter:
                # Sleep for a tiny moment to cause an overlap of the context
                # managers.
                time.sleep(0.01)
                record.append(pytorch_trainer.get_current_reporter())

        record1 = []  # The current repoter in each thread is stored here.
        record2 = []
        reporter1 = pytorch_trainer.Reporter()
        reporter2 = pytorch_trainer.Reporter()
        thread1 = threading.Thread(
            target=thread_func,
            args=(reporter1, record1))
        thread2 = threading.Thread(
            target=thread_func,
            args=(reporter2, record2))
        thread1.daemon = True
        thread2.daemon = True
        thread1.start()
        thread2.start()
        thread1.join()
        thread2.join()
        self.assertIs(record1[0], reporter1)
        self.assertIs(record2[0], reporter2)
コード例 #2
0
 def test_enter_exit(self):
     reporter1 = pytorch_trainer.Reporter()
     reporter2 = pytorch_trainer.Reporter()
     with reporter1:
         self.assertIs(pytorch_trainer.get_current_reporter(), reporter1)
         with reporter2:
             self.assertIs(pytorch_trainer.get_current_reporter(), reporter2)
         self.assertIs(pytorch_trainer.get_current_reporter(), reporter1)
コード例 #3
0
 def test_scope(self):
     reporter1 = pytorch_trainer.Reporter()
     reporter2 = pytorch_trainer.Reporter()
     with reporter1:
         observation = {}
         with reporter2.scope(observation):
             self.assertIs(pytorch_trainer.get_current_reporter(), reporter2)
             self.assertIs(reporter2.observation, observation)
         self.assertIs(pytorch_trainer.get_current_reporter(), reporter1)
         self.assertIsNot(reporter2.observation, observation)
コード例 #4
0
    def test_evaluate(self):
        reporter = pytorch_trainer.Reporter()
        reporter.add_observer('target', self.target)
        with reporter:
            mean = self.evaluator.evaluate()

        # No observation is reported to the current reporter. Instead the
        # evaluator collect results in order to calculate their mean.
        self.assertEqual(len(reporter.observation), 0)

        # The converter gets results of the iterator.
        self.assertEqual(len(self.converter.args), len(self.data))
        for i in range(len(self.data)):
            numpy.testing.assert_array_equal(self.converter.args[i]['batch'],
                                             self.data[i])
            self.assertIsNone(self.converter.args[i]['device'])

        # The model gets results of converter.
        self.assertEqual(len(self.target.args), len(self.batches))
        for i in range(len(self.batches)):
            numpy.testing.assert_array_equal(self.target.args[i],
                                             self.batches[i])

        self.assertAlmostEqual(mean['target/loss'], self.expect_mean, places=4)

        self.evaluator.finalize()
        self.assertTrue(self.iterator.finalized)
コード例 #5
0
    def test_evaluate(self):
        data = self.data
        batches = self.batches
        device = self.device

        iterator, converter, target, evaluator = (self.prepare(
            data, batches, device))

        reporter = pytorch_trainer.Reporter()
        reporter.add_observer('target', target)
        with reporter:
            mean = evaluator.evaluate()

        # The converter gets results of the iterator and the device number.
        self.assertEqual(len(converter.args), len(data))
        expected_device_arg = self.device

        for i in range(len(data)):
            numpy.testing.assert_array_equal(
                converter.args[i]['batch'].cpu().numpy(), self.data[i])
            self.assertEqual(converter.args[i]['device'].type,
                             expected_device_arg)

        # The model gets results of converter.
        self.assertEqual(len(target.args), len(batches))
        for i in range(len(batches)):
            self.assertEqual(target.args[i], self.batches[i])

        expect_mean = torch.stack([torch.stack(x).sum()
                                   for x in self.batches]).mean()
        self.assertAlmostEqual(mean['target/loss'].cpu().numpy(),
                               expect_mean.cpu().numpy(),
                               places=4)
コード例 #6
0
 def test_report(self):
     reporter = pytorch_trainer.Reporter()
     with reporter:
         pytorch_trainer.report({'x': 1})
     observation = reporter.observation
     self.assertIn('x', observation)
     self.assertEqual(observation['x'], 1)
コード例 #7
0
 def test_report_with_observer(self):
     reporter = pytorch_trainer.Reporter()
     observer = object()
     reporter.add_observer('o', observer)
     with reporter:
         pytorch_trainer.report({'x': 1}, observer)
     observation = reporter.observation
     self.assertIn('o/x', observation)
     self.assertEqual(observation['o/x'], 1)
コード例 #8
0
    def test_evaluate(self):
        reporter = pytorch_trainer.Reporter()
        reporter.add_observer('target', self.target)
        with reporter:
            self.evaluator.evaluate()

        # The model gets results of converter.
        self.assertEqual(len(self.target.args), len(self.batches))
        for i in range(len(self.batches)):
            numpy.testing.assert_array_equal(self.target.args[i],
                                             self.batches[i])
コード例 #9
0
    def test_report_scope(self):
        reporter = pytorch_trainer.Reporter()
        observation = {}

        with reporter:
            with pytorch_trainer.report_scope(observation):
                pytorch_trainer.report({'x': 1})

        self.assertIn('x', observation)
        self.assertEqual(observation['x'], 1)
        self.assertNotIn('x', reporter.observation)
コード例 #10
0
    def test_evaluate(self):
        reporter = pytorch_trainer.Reporter()
        reporter.add_observer('target', self.target)
        with reporter:
            mean = self.evaluator.evaluate()

        # The model gets results of converter.
        self.assertEqual(len(self.target.args), len(self.batches))
        for i in range(len(self.batches)):
            numpy.testing.assert_array_equal(self.target.args[i][0],
                                             self.batches[i]['x'])
            numpy.testing.assert_array_equal(self.target.args[i][1],
                                             self.batches[i]['y'])

        expect_mean = torch.stack(
            [x['x'].sum() + x['y'].sum() for x in self.batches]).mean()
        self.assertAlmostEqual(mean['target/loss'].cpu().numpy(),
                               expect_mean.cpu().numpy(),
                               places=4)
コード例 #11
0
    def test_add_observers(self):
        reporter = pytorch_trainer.Reporter()
        observer1 = object()
        reporter.add_observer('o1', observer1)
        observer2 = object()
        reporter.add_observer('o2', observer2)

        reporter.report({'x': 1}, observer1)
        reporter.report({'y': 2}, observer2)

        observation = reporter.observation
        self.assertIn('o1/x', observation)
        self.assertEqual(observation['o1/x'], 1)
        self.assertIn('o2/y', observation)
        self.assertEqual(observation['o2/y'], 2)
        self.assertNotIn('x', observation)
        self.assertNotIn('y', observation)
        self.assertNotIn('o1/y', observation)
        self.assertNotIn('o2/x', observation)
コード例 #12
0
 def test_evaluator(self):
     reporter = pytorch_trainer.Reporter()
     reporter.add_observer('target', self.target)
     with reporter:
         self.evaluator.evaluate()
コード例 #13
0
 def test_current_report(self):
     reporter = pytorch_trainer.Reporter()
     with reporter:
         mean = self.evaluator()
     # The result is reported to the current reporter.
     self.assertEqual(reporter.observation, mean)
コード例 #14
0
 def test_empty_reporter(self):
     reporter = pytorch_trainer.Reporter()
     self.assertEqual(reporter.observation, {})
コード例 #15
0
 def test_report_with_unregistered_observer(self):
     reporter = pytorch_trainer.Reporter()
     observer = object()
     with reporter:
         with self.assertRaises(KeyError):
             pytorch_trainer.report({'x': 1}, observer)
コード例 #16
0
 def test_keep_graph_default(self):
     x = torch.from_numpy(numpy.array([1], numpy.float32)).requires_grad_(True)
     y = functional.sigmoid(x)
     reporter = pytorch_trainer.Reporter()
     reporter.report({'y': y})
     self.assertFalse(reporter.observation['y'].requires_grad)