|
|
|
|
|
""" |
|
Non signal processing related utilities. |
|
""" |
|
|
|
import inspect |
|
import typing as tp |
|
import sys |
|
import time |
|
|
|
|
|
def simple_repr(obj, attrs: tp.Optional[tp.Sequence[str]] = None, |
|
overrides: dict = {}): |
|
""" |
|
Return a simple representation string for `obj`. |
|
If `attrs` is not None, it should be a list of attributes to include. |
|
""" |
|
params = inspect.signature(obj.__class__).parameters |
|
attrs_repr = [] |
|
if attrs is None: |
|
attrs = list(params.keys()) |
|
for attr in attrs: |
|
display = False |
|
if attr in overrides: |
|
value = overrides[attr] |
|
elif hasattr(obj, attr): |
|
value = getattr(obj, attr) |
|
else: |
|
continue |
|
if attr in params: |
|
param = params[attr] |
|
if param.default is inspect._empty or value != param.default: |
|
display = True |
|
else: |
|
display = True |
|
|
|
if display: |
|
attrs_repr.append(f"{attr}={value}") |
|
return f"{obj.__class__.__name__}({','.join(attrs_repr)})" |
|
|
|
|
|
class MarkdownTable: |
|
""" |
|
Simple MarkdownTable generator. The column titles should be large enough |
|
for the lines content. This will right align everything. |
|
|
|
>>> import io # we use io purely for test purposes, default is sys.stdout. |
|
>>> file = io.StringIO() |
|
>>> table = MarkdownTable(["Item Name", "Price"], file=file) |
|
>>> table.header(); table.line(["Honey", "5"]); table.line(["Car", "5,000"]) |
|
>>> print(file.getvalue().strip()) # Strip for test purposes |
|
| Item Name | Price | |
|
|-----------|-------| |
|
| Honey | 5 | |
|
| Car | 5,000 | |
|
""" |
|
def __init__(self, columns, file=sys.stdout): |
|
self.columns = columns |
|
self.file = file |
|
|
|
def _writeln(self, line): |
|
self.file.write("|" + "|".join(line) + "|\n") |
|
|
|
def header(self): |
|
self._writeln(f" {col} " for col in self.columns) |
|
self._writeln("-" * (len(col) + 2) for col in self.columns) |
|
|
|
def line(self, line): |
|
out = [] |
|
for val, col in zip(line, self.columns): |
|
val = format(val, '>' + str(len(col))) |
|
out.append(" " + val + " ") |
|
self._writeln(out) |
|
|
|
|
|
class Chrono: |
|
""" |
|
Measures ellapsed time, calling `torch.cuda.synchronize` if necessary. |
|
`Chrono` instances can be used as context managers (e.g. with `with`). |
|
Upon exit of the block, you can access the duration of the block in seconds |
|
with the `duration` attribute. |
|
|
|
>>> with Chrono() as chrono: |
|
... _ = sum(range(10_000)) |
|
... |
|
>>> print(chrono.duration < 10) # Should be true unless on a really slow computer. |
|
True |
|
""" |
|
def __init__(self): |
|
self.duration = None |
|
|
|
def __enter__(self): |
|
self._begin = time.time() |
|
return self |
|
|
|
def __exit__(self, exc_type, exc_value, exc_tracebck): |
|
import torch |
|
if torch.cuda.is_available(): |
|
torch.cuda.synchronize() |
|
self.duration = time.time() - self._begin |
|
|
