-
Notifications
You must be signed in to change notification settings - Fork 5
Expand file tree
/
Copy pathlog_helper.py
More file actions
executable file
·181 lines (167 loc) · 6.53 KB
/
Copy pathlog_helper.py
File metadata and controls
executable file
·181 lines (167 loc) · 6.53 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
import json
import logging
import os
import numpy as np
import yaml
from tabulate import tabulate
from tensorboardX import SummaryWriter
from typing import Optional, Tuple, Union, Dict, Any
def build_logger(
path: str,
name: Optional[str] = None,
need_tb: bool = True,
need_text: bool = True,
text_level: Union[int, str] = logging.INFO
) -> Tuple[Optional[logging.Logger], Optional['SummaryWriter']]: # noqa
r'''
Overview:
Build text logger and tensorboard logger.
Arguments:
- path (:obj:`str`): Logger(``Textlogger`` & ``SummaryWriter``)'s saved dir
- name (:obj:`str`): The logger file name
- need_tb (:obj:`bool`): Whether ``SummaryWriter`` instance would be created and returned
- need_text (:obj:`bool`): Whether ``loggingLogger`` instance would be created and returned
- text_level (:obj:`int`` or :obj:`str`): Logging level of ``logging.Logger``, default set to ``logging.INFO``
Returns:
- logger (:obj:`Optional[logging.Logger]`): Logger that displays terminal output
- tb_logger (:obj:`Optional['SummaryWriter']`): Saves output to tfboard, only return when ``need_tb``.
'''
if name is None:
name = 'default'
logger = LoggerFactory.create_logger(path, name=name) if need_text else None
tb_name = name + '_tb_logger'
tb_logger = SummaryWriter(os.path.join(path, tb_name)) if need_tb else None
return logger, tb_logger
class LoggerFactory(object):
@classmethod
def create_logger(cls, path: str, name: str = 'default', level: Union[int, str] = logging.INFO) -> logging.Logger:
r"""
Overview:
Create logger using logging
Arguments:
- name (:obj:`str`): Logger's name
- path (:obj:`str`): Logger's save dir
- level (:obj:`int` or :obj:`str`): Used to set the level. Reference: ``Logger.setLevel`` method.
Returns:
- (:obj:`logging.Logger`): new logging logger
"""
name += '_logger'
# ensure the path exists
try:
os.makedirs(path)
except FileExistsError:
pass
logger = logging.getLogger(name)
logger_file_path = os.path.join(path, name + '.txt')
if not logger.handlers:
formatter = logging.Formatter('[%(asctime)s][%(filename)15s][line:%(lineno)4d][%(levelname)8s] %(message)s')
fh = logging.FileHandler(logger_file_path, 'a')
fh.setFormatter(formatter)
logger.setLevel(level)
logger.addHandler(fh)
logger.get_tabulate_vars = LoggerFactory.get_tabulate_vars
logger.get_tabulate_vars_hor = LoggerFactory.get_tabulate_vars_hor
return logger
@staticmethod
def get_tabulate_vars(variables: Dict[str, Any]) -> str:
r"""
Overview:
Get the text description in tabular form of all vars
Arguments:
- variables (:obj:`List[str]`): Names of the vars to query.
Returns:
- string (:obj:`str`): Text description in tabular form of all vars
"""
headers = ["Name", "Value"]
data = []
for k, v in variables.items():
data.append([k, "{:.6f}".format(v)])
s = "\n" + tabulate(data, headers=headers, tablefmt='grid')
return s
@staticmethod
def get_tabulate_vars_hor(variables: Dict[str, Any]) -> str:
datak = []
datav = []
datak.append("Name")
datav.append("Value")
for k, v in variables.items():
datak.append(k)
if not isinstance(v, str) and np.isscalar(v):
datav.append("{:.6f}".format(v))
else:
datav.append(v)
data = [datak, datav]
s = "\n" + tabulate(data, tablefmt='grid')
return s
class DistributionTimeImage:
r"""
Overview:
``DistributionTimeImage`` can be used to store images accorrding to ``time_steps``,
for data with 3 dims``(time, category, value)``
Interface:
``__init__``, ``add_one_time_step``, ``get_image``
"""
def __init__(self, maxlen: int = 600, val_range: Optional[dict] = None):
r"""
Overview:
Init the ``DistributionTimeImage`` class
Arguments:
- maxlen (:obj:`int`): The max length of data inputs
- val_range (:obj:`dict` or :obj:`None`): Dict with ``val_range['min']`` and ``val_range['max']``.
"""
self.maxlen = maxlen
self.val_range = val_range
self.img = np.ones((maxlen, maxlen))
self.time_step = 0
self.one_img = np.ones((maxlen, maxlen))
def add_one_time_step(self, data: np.ndarray) -> None:
r"""
Overview:
Step one timestep in ``DistributionTimeImage`` and add the data to distribution image
Arguments:
- data (:obj:`np.ndarray`): The data input
"""
assert (isinstance(data, np.ndarray))
data = np.expand_dims(data, 1)
data = np.resize(data, (1, self.maxlen))
if self.time_step >= self.maxlen:
self.img = np.concatenate([self.img[:, 1:], data])
else:
self.img[:, self.time_step:self.time_step + 1] = data
self.time_step += 1
def get_image(self) -> np.ndarray:
r"""
Overview:
Return the distribution image
Returns:
- img (:obj:`np.ndarray`): The calculated distribution image
"""
norm_img = np.copy(self.img)
valid = norm_img[:, :self.time_step]
if self.val_range is None:
valid = (valid - valid.min()) / (valid.max() - valid.min())
else:
valid = np.clip(valid, self.val_range['min'], self.val_range['max'])
valid = (valid - self.val_range['min']) / (self.val_range['max'] - self.val_range['min'])
norm_img[:, :self.time_step] = valid
return np.stack([self.one_img, norm_img, norm_img], axis=0)
def pretty_print(result: dict, direct_print: bool = True) -> str:
r"""
Overview:
Print a dict ``result`` in a pretty way
Arguments:
- result (:obj:`dict`): The result to print
- direct_print (:obj:`bool`): Whether to print directly
Returns:
- string (:obj:`str`): The pretty-printed result in str format
"""
result = result.copy()
out = {}
for k, v in result.items():
if v is not None:
out[k] = v
cleaned = json.dumps(out)
string = yaml.safe_dump(json.loads(cleaned), default_flow_style=False)
if direct_print:
print(string)
return string