You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
208 lines
7.9 KiB
208 lines
7.9 KiB
# Copyright (c) 2020 PaddlePaddle 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. |
|
|
|
import os |
|
import sys |
|
import time |
|
|
|
import numpy as np |
|
|
|
|
|
class Progbar(object): |
|
""" |
|
Displays a progress bar. |
|
It refers to https://github.com/keras-team/keras/blob/keras-2/keras/utils/generic_utils.py |
|
|
|
Args: |
|
target (int): Total number of steps expected, None if unknown. |
|
width (int): Progress bar width on screen. |
|
verbose (int): Verbosity mode, 0 (silent), 1 (verbose), 2 (semi-verbose) |
|
stateful_metrics (list|tuple): Iterable of string names of metrics that should *not* be |
|
averaged over time. Metrics in this list will be displayed as-is. All |
|
others will be averaged by the progbar before display. |
|
interval (float): Minimum visual progress update interval (in seconds). |
|
unit_name (str): Display name for step counts (usually "step" or "sample"). |
|
""" |
|
|
|
def __init__(self, |
|
target, |
|
width=30, |
|
verbose=1, |
|
interval=0.05, |
|
stateful_metrics=None, |
|
unit_name='step'): |
|
self.target = target |
|
self.width = width |
|
self.verbose = verbose |
|
self.interval = interval |
|
self.unit_name = unit_name |
|
if stateful_metrics: |
|
self.stateful_metrics = set(stateful_metrics) |
|
else: |
|
self.stateful_metrics = set() |
|
|
|
self._dynamic_display = ( |
|
(hasattr(sys.stderr, 'isatty') and |
|
sys.stderr.isatty()) or 'ipykernel' in sys.modules or |
|
'posix' in sys.modules or 'PYCHARM_HOSTED' in os.environ) |
|
self._total_width = 0 |
|
self._seen_so_far = 0 |
|
# We use a dict + list to avoid garbage collection |
|
# issues found in OrderedDict |
|
self._values = {} |
|
self._values_order = [] |
|
self._start = time.time() |
|
self._last_update = 0 |
|
|
|
def update(self, current, values=None, finalize=None): |
|
""" |
|
Updates the progress bar. |
|
|
|
Args: |
|
current (int): Index of current step. |
|
values (list): List of tuples: `(name, value_for_last_step)`. If `name` is in |
|
`stateful_metrics`, `value_for_last_step` will be displayed as-is. |
|
Else, an average of the metric over time will be displayed. |
|
finalize (bool): Whether this is the last update for the progress bar. If |
|
`None`, defaults to `current >= self.target`. |
|
""" |
|
|
|
if finalize is None: |
|
if self.target is None: |
|
finalize = False |
|
else: |
|
finalize = current >= self.target |
|
|
|
values = values or [] |
|
for k, v in values: |
|
if k not in self._values_order: |
|
self._values_order.append(k) |
|
if k not in self.stateful_metrics: |
|
# In the case that progress bar doesn't have a target value in the first |
|
# epoch, both on_batch_end and on_epoch_end will be called, which will |
|
# cause 'current' and 'self._seen_so_far' to have the same value. Force |
|
# the minimal value to 1 here, otherwise stateful_metric will be 0s. |
|
value_base = max(current - self._seen_so_far, 1) |
|
if k not in self._values: |
|
self._values[k] = [v * value_base, value_base] |
|
else: |
|
self._values[k][0] += v * value_base |
|
self._values[k][1] += value_base |
|
else: |
|
# Stateful metrics output a numeric value. This representation |
|
# means "take an average from a single value" but keeps the |
|
# numeric formatting. |
|
self._values[k] = [v, 1] |
|
self._seen_so_far = current |
|
|
|
now = time.time() |
|
info = ' - %.0fs' % (now - self._start) |
|
if self.verbose == 1: |
|
if now - self._last_update < self.interval and not finalize: |
|
return |
|
|
|
prev_total_width = self._total_width |
|
if self._dynamic_display: |
|
sys.stderr.write('\b' * prev_total_width) |
|
sys.stderr.write('\r') |
|
else: |
|
sys.stderr.write('\n') |
|
|
|
if self.target is not None: |
|
numdigits = int(np.log10(self.target)) + 1 |
|
bar = ('%' + str(numdigits) + 'd/%d [') % (current, self.target) |
|
prog = float(current) / self.target |
|
prog_width = int(self.width * prog) |
|
if prog_width > 0: |
|
bar += ('=' * (prog_width - 1)) |
|
if current < self.target: |
|
bar += '>' |
|
else: |
|
bar += '=' |
|
bar += ('.' * (self.width - prog_width)) |
|
bar += ']' |
|
else: |
|
bar = '%7d/Unknown' % current |
|
|
|
self._total_width = len(bar) |
|
sys.stderr.write(bar) |
|
|
|
if current: |
|
time_per_unit = (now - self._start) / current |
|
else: |
|
time_per_unit = 0 |
|
|
|
if self.target is None or finalize: |
|
if time_per_unit >= 1 or time_per_unit == 0: |
|
info += ' %.0fs/%s' % (time_per_unit, self.unit_name) |
|
elif time_per_unit >= 1e-3: |
|
info += ' %.0fms/%s' % (time_per_unit * 1e3, self.unit_name) |
|
else: |
|
info += ' %.0fus/%s' % (time_per_unit * 1e6, self.unit_name) |
|
else: |
|
eta = time_per_unit * (self.target - current) |
|
if eta > 3600: |
|
eta_format = '%d:%02d:%02d' % (eta // 3600, |
|
(eta % 3600) // 60, eta % 60) |
|
elif eta > 60: |
|
eta_format = '%d:%02d' % (eta // 60, eta % 60) |
|
else: |
|
eta_format = '%ds' % eta |
|
|
|
info = ' - ETA: %s' % eta_format |
|
|
|
for k in self._values_order: |
|
info += ' - %s:' % k |
|
if isinstance(self._values[k], list): |
|
avg = np.mean(self._values[k][0] / |
|
max(1, self._values[k][1])) |
|
if abs(avg) > 1e-3: |
|
info += ' %.4f' % avg |
|
else: |
|
info += ' %.4e' % avg |
|
else: |
|
info += ' %s' % self._values[k] |
|
|
|
self._total_width += len(info) |
|
if prev_total_width > self._total_width: |
|
info += (' ' * (prev_total_width - self._total_width)) |
|
|
|
if finalize: |
|
info += '\n' |
|
|
|
sys.stderr.write(info) |
|
sys.stderr.flush() |
|
|
|
elif self.verbose == 2: |
|
if finalize: |
|
numdigits = int(np.log10(self.target)) + 1 |
|
count = ('%' + str(numdigits) + 'd/%d') % (current, self.target) |
|
info = count + info |
|
for k in self._values_order: |
|
info += ' - %s:' % k |
|
avg = np.mean(self._values[k][0] / |
|
max(1, self._values[k][1])) |
|
if avg > 1e-3: |
|
info += ' %.4f' % avg |
|
else: |
|
info += ' %.4e' % avg |
|
info += '\n' |
|
|
|
sys.stderr.write(info) |
|
sys.stderr.flush() |
|
|
|
self._last_update = now |
|
|
|
def add(self, n, values=None): |
|
self.update(self._seen_so_far + n, values)
|
|
|