text stringlengths 1 93.6k |
|---|
d = torch.tensor(list(self.deque))
|
return d.median().item()
|
@property
|
def avg(self):
|
d = torch.tensor(list(self.deque), dtype=torch.float32)
|
return d.mean().item()
|
@property
|
def global_avg(self):
|
return self.total / self.count
|
@property
|
def max(self):
|
return max(self.deque)
|
@property
|
def value(self):
|
return self.deque[-1]
|
def __str__(self):
|
return self.fmt.format(
|
median=self.median,
|
avg=self.avg,
|
global_avg=self.global_avg,
|
max=self.max,
|
value=self.value)
|
class MetricLogger(object):
|
def __init__(self, delimiter="\t", logger=logging):
|
self.meters = defaultdict(SmoothedValue)
|
self.delimiter = delimiter
|
self.logger = logger
|
def update(self, **kwargs):
|
for k, v in kwargs.items():
|
if isinstance(v, torch.Tensor):
|
v = v.item()
|
assert isinstance(v, (float, int))
|
self.meters[k].update(v)
|
def __getattr__(self, attr):
|
if attr in self.meters:
|
return self.meters[attr]
|
if attr in self.__dict__:
|
return self.__dict__[attr]
|
raise AttributeError("'{}' object has no attribute '{}'".format(
|
type(self).__name__, attr))
|
def __str__(self):
|
loss_str = []
|
for name, meter in self.meters.items():
|
loss_str.append(
|
"{}: {}".format(name, str(meter))
|
)
|
return self.delimiter.join(loss_str)
|
def synchronize_between_processes(self):
|
for meter in self.meters.values():
|
meter.synchronize_between_processes()
|
def add_meter(self, name, meter):
|
self.meters[name] = meter
|
def log_every(self, iterable, print_freq, header=None):
|
i = 0
|
if not header:
|
header = ''
|
start_time = time.time()
|
end = time.time()
|
iter_time = SmoothedValue(fmt='{avg:.4f}')
|
data_time = SmoothedValue(fmt='{avg:.4f}')
|
space_fmt = ':' + str(len(str(len(iterable)))) + 'd'
|
log_msg = [
|
header,
|
'[{0' + space_fmt + '}/{1}]',
|
'eta: {eta}',
|
'{meters}',
|
'time: {time}',
|
'data: {data}'
|
]
|
if torch.cuda.is_available():
|
log_msg.append('max mem: {memory:.0f}')
|
log_msg = self.delimiter.join(log_msg)
|
MB = 1024.0 * 1024.0
|
for obj in iterable:
|
data_time.update(time.time() - end)
|
yield obj
|
iter_time.update(time.time() - end)
|
if i % print_freq == 0 or i == len(iterable) - 1:
|
eta_seconds = iter_time.global_avg * (len(iterable) - i)
|
eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
|
if torch.cuda.is_available():
|
self.logger.info(log_msg.format(
|
i, len(iterable), eta=eta_string,
|
meters=str(self),
|
time=str(iter_time), data=str(data_time),
|
memory=torch.cuda.max_memory_allocated() / MB))
|
else:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.