8692929573

Committed 15 Apr 2024 04:46PM UTC coverage: 15.691%. Remained the same

Build # 8692929573

Build Type

push

github

Committed by

yeliudev

Commit Message

Fix timer

Run Details

2 of 6 new or added lines in 2 files covered. (33.33%)

678 of 4321 relevant lines covered (15.69%)

3.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/nncore/engine/hooks/timer.py

# Copyright (c) Ye Liu. Licensed under the MIT License.

from datetime import timedelta

import nncore
from ..builder import HOOKS
from ..comm import main_only
from .base import Hook


@HOOKS.register()
class TimerHook(Hook):
    """
    Compute and save timings into :obj:`enging.buffer` during training.
    """

    def __init__(self):
        super(TimerHook, self).__init__()
        self._total_timer = nncore.Timer()
        self._iter_timer = nncore.Timer()
        self._data_timer = nncore.Timer()
        self._train_timer = nncore.Timer()
        self._val_timer = nncore.Timer()

    def _update_time(self, engine, keys):
        for key in keys:
            engine.buffer.update(
                '_{}_time'.format(key),
                getattr(self, '_{}_timer'.format(key)).seconds())

    @main_only
    def before_launch(self, engine):
        self._total_timer.reset()
        self._data_timer.reset()
        self._train_timer.reset()
        self._train_timer.pause()
        self._val_timer.reset()
        self._val_timer.pause()

    @main_only
    def after_launch(self, engine):
        total_time = self._total_timer.seconds()
        train_time = self._train_timer.seconds()
        val_time = self._val_timer.seconds()

        hook_time = total_time - train_time - val_time
        num_iters = engine.iter - engine.start_iter

        if num_iters > 0 and train_time > 0:
            engine.logger.info(
                'Overall training speed: {} iterations in {} ({:.4f} s/it)'.
                format(num_iters, timedelta(seconds=int(train_time)),
                       train_time / num_iters))

        engine.logger.info('Done running in {} ({} on hooks)'.format(
            timedelta(seconds=int(total_time)),
            timedelta(seconds=int(hook_time))))

    @main_only
    def before_epoch(self, engine):
        for key in list(engine.buffer.keys()):
            if key in ('total', 'iter', 'data', 'train', 'val'):
                engine.buffer.pop('_{}_time'.format(key))

    @main_only
    def before_train_iter(self, engine):
        self._iter_timer.reset()
        self._train_timer.resume()
        self._update_time(engine, ['data'])

    @main_only
    def after_train_iter(self, engine):
        self._data_timer.reset()
        self._train_timer.pause()
        self._update_time(engine, ['total', 'iter', 'train'])

    @main_only
    def before_val_iter(self, engine):
        self._iter_timer.reset()
        self._val_timer.resume(raise_error=False)
        self._update_time(engine, ['data'])

    @main_only
    def after_val_iter(self, engine):
        self._data_timer.reset()
        self._val_timer.pause(raise_error=False)
        self._update_time(engine, ['total', 'iter', 'val'])

1	# Copyright (c) Ye Liu. Licensed under the MIT License.
2
3	from datetime import timedelta	×
4
5	import nncore	×
6	from ..builder import HOOKS	×
7	from ..comm import main_only	×
8	from .base import Hook	×
9
10
11	@HOOKS.register()	×
12	class TimerHook(Hook):	×
13	"""
14	Compute and save timings into :obj:`enging.buffer` during training.
15	"""
16
17	def __init__(self):	×
18	super(TimerHook, self).__init__()	×
19	self._total_timer = nncore.Timer()	×
20	self._iter_timer = nncore.Timer()	×
21	self._data_timer = nncore.Timer()	×
22	self._train_timer = nncore.Timer()	×
23	self._val_timer = nncore.Timer()	×
24
25	def _update_time(self, engine, keys):	×
26	for key in keys:	×
27	engine.buffer.update(	×
28	'_{}_time'.format(key),
29	getattr(self, '_{}_timer'.format(key)).seconds())
30
31	@main_only	×
32	def before_launch(self, engine):	×
33	self._total_timer.reset()	×
34	self._data_timer.reset()	×
35	self._train_timer.reset()	×
36	self._train_timer.pause()	×
37	self._val_timer.reset()	×
38	self._val_timer.pause()	×
39
40	@main_only	×
41	def after_launch(self, engine):	×
42	total_time = self._total_timer.seconds()	×
43	train_time = self._train_timer.seconds()	×
44	val_time = self._val_timer.seconds()	×
45
46	hook_time = total_time - train_time - val_time	×
47	num_iters = engine.iter - engine.start_iter	×
48
49	if num_iters > 0 and train_time > 0:	×
50	engine.logger.info(	×
51	'Overall training speed: {} iterations in {} ({:.4f} s/it)'.
52	format(num_iters, timedelta(seconds=int(train_time)),
53	train_time / num_iters))
54
55	engine.logger.info('Done running in {} ({} on hooks)'.format(	×
56	timedelta(seconds=int(total_time)),
57	timedelta(seconds=int(hook_time))))
58
59	@main_only	×
60	def before_epoch(self, engine):	×
61	for key in list(engine.buffer.keys()):	×
62	if key in ('total', 'iter', 'data', 'train', 'val'):	×
63	engine.buffer.pop('_{}_time'.format(key))	×
64
65	@main_only	×
66	def before_train_iter(self, engine):	×
67	self._iter_timer.reset()	×
68	self._train_timer.resume()	×
69	self._update_time(engine, ['data'])	×
70
71	@main_only	×
72	def after_train_iter(self, engine):	×
73	self._data_timer.reset()	×
74	self._train_timer.pause()	×
75	self._update_time(engine, ['total', 'iter', 'train'])	×
76
77	@main_only	×
78	def before_val_iter(self, engine):	×
79	self._iter_timer.reset()	×
NEW 80	self._val_timer.resume(raise_error=False)	×
81	self._update_time(engine, ['data'])	×
82
83	@main_only	×
84	def after_val_iter(self, engine):	×
85	self._data_timer.reset()	×
NEW 86	self._val_timer.pause(raise_error=False)	×
87	self._update_time(engine, ['total', 'iter', 'val'])	×

yeliudev / nncore / 8692929573

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous