code stringlengths 17 6.64M |
|---|
class BaseNetworkFactory(ABC):
def __init__(self, input_spec: InputSpec, network_config: NetworkConfig, conv_config: Optional[ConvolutionConfig]=None, net_weights: Optional[NetWeights]=None):
if (net_weights is None):
net_weights = NetWeights(x=NetWeight(1.0, 1.0, 1.0), v=NetWeight(1.0, 1.0, ... |
class TimePotentialSU3(nn.Module):
def __init__(self) -> None:
super(TimePotentialSU3, self).__init__()
self.full_eigdecomp = su3_to_eigs_cdesa
self.deepset = ComplexDeepTimeSet(1, 1, hidden_channels=64)
def forward(self, t: Tensor, x: Tensor) -> Tensor:
x = self.full_eigdeco... |
class SU3TimeEquivariantVectorField(nn.Module):
def __init__(self, func):
super(SU3TimeEquivariantVectorField, self).__init__()
self.func = func
def forward(self, t: Tensor, x: Tensor) -> Tensor:
return torch.autograd.grad(self.func(t, x).squeeze().sum(), x, create_graph=True, retain... |
class AmbientProjNN(nn.Module):
def __init__(self, func):
super(AmbientProjNN, self).__init__()
self.func = func
self.man = SUN()
def forward(self, t: Tensor, x: Tensor) -> Tensor:
self.man.proju(x, self.func(t, x))
|
def linear_activation(x: Tensor) -> Tensor:
return x
|
def get_activation(act_fn: (str | Callable)) -> Callable:
if isinstance(act_fn, Callable):
return act_fn
act_fn = Activation(act_fn)
assert callable(act_fn)
return act_fn
|
def dummy_network(inputs: tuple[(Tensor, Tensor)], training: Optional[bool]=None) -> tuple[(Tensor, Tensor, Tensor)]:
(_, v) = inputs
return (tf.zeros_like(v), tf.zeros_like(v), tf.zeros_like(v))
|
def zero_weights(model: Model) -> Model:
for layer in model.layers:
if isinstance(layer, Model):
zero_weights(layer)
else:
weights = layer.get_weights()
zeros = []
for w in weights:
log.info(f'Zeroing layer: {layer}')
... |
class ScaledTanh(Layer):
def __init__(self, out_features: int, name: Optional[str], **kwargs) -> None:
super(ScaledTanh, self).__init__(name=name, **kwargs)
self.out_features = out_features
self.dense = Dense(out_features)
def get_layer_weights(self) -> dict:
return {'coeff':... |
class ConvStack(Layer):
def __init__(self, xshape: Sequence[int], conv_config: ConvolutionConfig, activation_fn: (str | Callable), use_batch_norm: bool=False, name: Optional[str]=None, **kwargs) -> None:
super(ConvStack, self).__init__(name=name, **kwargs)
self.conv_config = conv_config
s... |
class InputLayer(Model):
def __init__(self, xshape: Sequence[int], network_config: NetworkConfig, activation_fn: (str | Callable[([Tensor], Tensor)]), conv_config: Optional[ConvolutionConfig]=None, input_shapes: Optional[dict[(str, (int | Sequence[int]))]]=None, name: Optional[str]=None) -> None:
super(I... |
class LeapfrogLayer(Model):
def __init__(self, xshape: Sequence[int], network_config: NetworkConfig, group: Optional[((U1Phase | SU3) | str)]=None, input_shapes: Optional[dict[(str, (int | Sequence[int]))]]=None, net_weight: Optional[NetWeight]=None, conv_config: Optional[ConvolutionConfig]=None, name: Optional[... |
class NetworkFactory(BaseNetworkFactory):
def build_xnet(self, group: (SU3 | U1Phase), name: Optional[str]=None) -> LeapfrogLayer:
xname = ('xnet' if (name is None) else f'xnet/{name}')
return LeapfrogLayer(xshape=self.input_spec.xshape, network_config=self.network_config, group=group, input_shap... |
def savefig(fig: plt.Figure, fname: str, outdir: os.PathLike):
pngfile = Path(outdir).joinpath(f'pngs/{fname}.png')
svgfile = Path(outdir).joinpath(f'svgs/{fname}.svg')
pngfile.parent.mkdir(exist_ok=True, parents=True)
svgfile.parent.mkdir(exist_ok=True, parents=True)
fig.savefig(svgfile, transpar... |
def plot_metrics(metrics: dict, title: Optional[str]=None, **kwargs):
outdir = Path(f'./plots-4dSU3/{title}')
outdir.mkdir(exist_ok=True, parents=True)
for (key, val) in metrics.items():
(fig, ax) = plot_metric(val, name=key, **kwargs)
if (title is not None):
ax.set_title(title... |
def plot_metric(metric: torch.Tensor, name: Optional[str]=None, **kwargs):
assert (len(metric) > 0)
if isinstance(metric[0], (int, float, bool, np.floating)):
y = np.stack(metric)
return plot_scalar(y, ylabel=name, **kwargs)
element_shape = metric[0].shape
if (len(element_shape) == 2):... |
def savefig(fig: plt.Figure, fname: str, outdir: os.PathLike):
pngfile = Path(outdir).joinpath(f'pngs/{fname}.png')
svgfile = Path(outdir).joinpath(f'svgs/{fname}.svg')
pngfile.parent.mkdir(exist_ok=True, parents=True)
svgfile.parent.mkdir(exist_ok=True, parents=True)
fig.savefig(svgfile, transpar... |
def plot_metrics(metrics: dict, title: Optional[str]=None, **kwargs):
outdir = Path(f'./plots-4dSU3/{title}')
outdir.mkdir(exist_ok=True, parents=True)
for (key, val) in metrics.items():
(fig, ax) = plot_metric(val, name=key, **kwargs)
if (title is not None):
ax.set_title(title... |
def plot_metric(metric: torch.Tensor, name: Optional[str]=None, **kwargs):
assert (len(metric) > 0)
if isinstance(metric[0], (int, float, bool, np.floating)):
y = np.stack(metric)
return plot_scalar(y, ylabel=name, **kwargs)
element_shape = metric[0].shape
if (len(element_shape) == 2):... |
def log_dict(writer: SummaryWriter, d: dict, step: Optional[int]=None, prefix: Optional[str]=None, nchains: Optional[int]=None) -> None:
'Create TensorBoard summaries for all items in `d`'
for (key, val) in d.items():
pre = (key if (prefix is None) else f'{prefix}/{key}')
if isinstance(val, di... |
def log_dict_wandb(d: dict, step: Optional[int]=None, prefix: Optional[str]=None, commit: bool=True) -> None:
'Create WandB summaries for all items in `d`'
if ((prefix is not None) and (step is not None)):
d |= {f'{prefix}/iter': step}
wandb.log((d if (prefix is None) else {f'{prefix}/{k}': v for ... |
def log_list(writer: SummaryWriter, x: list, prefix: str, step: Optional[int]=None, nchains: Optional[int]=None) -> None:
'Create TensorBoard summaries for all entries in `x`'
for t in x:
name = getattr(t, 'name', getattr(t, '__name__', None))
tag = (name if (prefix is None) else f'{prefix}/{n... |
def log_step(tag: str, step: int, writer: SummaryWriter) -> None:
iter_tag = '/'.join(([tag.split('/')[0]] + ['iter']))
writer.add_scalar(tag=iter_tag, scalar_value=step, global_step=step)
|
def check_tag(tag: str) -> str:
tags = tag.split('/')
return ('/'.join(tags[1:]) if ((len(tags) > 2) and (tags[0] == tags[1])) else tag)
|
def log_item(tag: str, val: (((((float | int) | bool) | list) | np.ndarray) | torch.Tensor), writer: SummaryWriter, step: Optional[int]=None, nchains: Optional[int]=None) -> None:
if (step is not None):
log_step(tag, step, writer)
tag = check_tag(tag)
if isinstance(val, (Tensor, Array)):
i... |
def as_tensor(x: ((torch.Tensor | list) | None), grab: bool=False, nchains: Optional[int]=None) -> (((torch.Tensor | None) | np.ndarray) | Scalar):
if (x is None):
return x
if (nchains is not None):
try:
x = x[:nchains]
except Exception:
pass
if isinstance(x... |
def log_params_and_grads(model: nn.Module, step: Optional[int]=None, with_grads: bool=True, nchains: Optional[int]=None) -> None:
if (wandb.run is None):
return
params = {f'params/{k}': as_tensor(v, nchains=nchains) for (k, v) in model.named_parameters()}
grads = {}
if with_grads:
grad... |
def update_summaries(writer: SummaryWriter, step: Optional[int]=None, metrics: Optional[dict[(str, ArrayLike)]]=None, model: Optional[torch.nn.Module]=None, prefix: str='', with_grads: bool=True, use_tb: bool=True, use_wandb: bool=True, nchains: int=8, optimizer: Optional[torch.optim.Optimizer]=None) -> None:
if ... |
def log_step(tag: str, step: int) -> None:
iter_tag = '/'.join(([tag.split('/')[0]] + ['iter']))
tf.summary.scalar(iter_tag, step, step=step)
|
def check_tag(tag: str) -> str:
tags = tag.split('/')
return ('/'.join(tags[1:]) if ((len(tags) > 2) and (tags[0] == tags[1])) else tag)
|
def log_item(tag: str, val: ((((((float | int) | bool) | list) | np.ndarray) | tf.Tensor) | None), step: Optional[int]=None):
if (val is None):
return
if (step is not None):
log_step(tag, step)
tag = check_tag(tag)
if isinstance(val, (Tensor, Array)):
if ((isinstance(val, Tenso... |
def log_dict(d: ((dict | DefaultDict) | Mapping), step: int, prefix: Optional[str]=None):
'Create tensorboard summaries for all items in `d`'
for (key, val) in d.items():
pre = (key if (prefix is None) else f'{prefix}/{key}')
if isinstance(val, dict):
log_dict(val, step=step, prefi... |
def log_list(x, step, prefix: Optional[str]=None):
for (idx, t) in enumerate(x):
name = getattr(t, 'name', getattr(t, '__name__', None))
if (name is None):
name = f'{idx}'
tag = (name if (prefix is None) else f'{prefix}/{name}')
assert (tag is not None)
log_item... |
def log_model_weights1(step: int, model: (tf.keras.Model | tf.keras.layers.Layer), prefix: Optional[str]=None):
prefix = (f'model/{prefix}' if (prefix is not None) else 'model')
name = getattr(model, 'name', None)
if (name is not None):
prefix += f'/{name}'
log_list(model.trainable_variables, ... |
def log_model_weights(step: int, model: (tf.keras.Model | tf.keras.layers.Layer), prefix: Optional[str]=None, sep: Optional[str]=None):
weights = model.weights
wdict = {w.name: w for w in weights}
if (sep is not None):
wdict.update({k.replace('/', sep): v for (k, v) in wdict.items()})
log_dict... |
def format_weight_name(name: str) -> str:
return name.rstrip(':0').replace('kernel', 'weight')
|
def update_summaries(step: int, metrics: Optional[dict[(str, Tensor)]]=None, model: Optional[Model]=None, optimizer: Optional[Optimizer]=None, prefix: Optional[str]=None) -> None:
if ((metrics is not None) and isinstance(metrics, dict)):
log_dict(metrics, step, prefix=prefix)
if (model is not None):
... |
def update_summaries1(step: int, metrics: Optional[dict]=None, model: Optional[(Model | Layer)]=None, weights: Optional[dict]=None, optimizer: Optional[Optimizer]=None, prefix: Optional[str]=None, job_type: Optional[str]=None, sep: Optional[str]=None):
'"Create summary objects.'
if (metrics is not None):
... |
def savefig(fig: plt.Figure, fname: str, outdir: os.PathLike):
pngfile = Path(outdir).joinpath(f'pngs/{fname}.png')
svgfile = Path(outdir).joinpath(f'svgs/{fname}.svg')
pngfile.parent.mkdir(exist_ok=True, parents=True)
svgfile.parent.mkdir(exist_ok=True, parents=True)
fig.savefig(svgfile, transpar... |
def HMC(experiment: Experiment, nsteps: int=10, beta: float=1.0, nlog: int=1, nprint: int=1, x: Optional[torch.Tensor]=None, eps: Optional[float]=None, nleapfrog: Optional[int]=None) -> tuple[(torch.Tensor, BaseHistory)]:
'Run HMC on `experiment`'
history_hmc = BaseHistory()
if (x is None):
state ... |
def eval(experiment: Experiment, nsteps: int=10, beta: float=1.0, nlog: int=1, nprint: int=2, x: Optional[torch.Tensor]=None) -> tuple[(torch.Tensor, BaseHistory)]:
'Run eval on `experiment`'
history_eval = BaseHistory()
if (x is None):
state = experiment.trainer.dynamics.random_state(beta=beta)
... |
def main() -> tuple[(torch.Tensor, dict[(str, BaseHistory)])]:
plt.style.use(opinionated.STYLES['opinionated_min'])
su3conf = Path('./conf/su3-min.yaml')
with su3conf.open('r') as stream:
conf = dict(yaml.safe_load(stream))
log.info(json.dumps(conf, indent=4))
overrides = dict_to_list_of_o... |
def grab(x: Tensor) -> np.ndarray:
return x.detach().cpu().numpy()
|
def load_ds_config(fpath: os.PathLike) -> dict:
ds_config_path = Path(fpath)
log.info(f'Loading DeepSpeed Config from: {ds_config_path.as_posix()}')
if (ds_config_path.suffix == '.json'):
with ds_config_path.open('r') as f:
ds_config = json.load(f)
return ds_config
if (ds_c... |
def box_header(header: str):
headerlen = (len(header) + 2)
log.info((('┏' + (headerlen * '━')) + '┓'))
log.info(f'┃ {header} ┃')
log.info((('┗' + (headerlen * '━')) + '┛'))
|
class Trainer(BaseTrainer):
def __init__(self, cfg: (DictConfig | ExperimentConfig), build_networks: bool=True, ckpt_dir: Optional[os.PathLike]=None, keep: Optional[(str | Sequence[str])]=None, skip: Optional[(str | Sequence[str])]=None) -> None:
super().__init__(cfg=cfg, keep=keep, skip=skip)
as... |
class BaseTrainer(ABC):
def __init__(self, cfg: (DictConfig | ExperimentConfig), keep: Optional[(str | Sequence[str])]=None, skip: Optional[(str | Sequence[str])]=None):
self._created = get_timestamp()
if isinstance(cfg, DictConfig):
self.config: ExperimentConfig = instantiate(cfg)
... |
def setup_tensorflow(precision: Optional[str]=None, ngpus: Optional[int]=None) -> int:
import tensorflow as tf
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
import horovod.tensorflow as hvd
(hvd.init() if (not hvd.is_initialized()) else None)
if (preci... |
def init_deepspeed():
import deepspeed
try:
deepspeed.init_distributed(dist_backend='nccl')
except Exception:
try:
deepspeed.init_distributed(dist_backend='mpi')
except RuntimeError:
deepspeed.init_distributed(dist_backend='gloo')
|
def init_process_group(rank: (int | str), world_size: (int | str), backend: Optional[str]=None) -> None:
import torch
import torch.distributed as dist
if torch.cuda.is_available():
backend = ('nccl' if (backend is None) else str(backend))
else:
backend = ('gloo' if (backend is None) el... |
def run_ddp(fn: Callable, world_size: int) -> None:
import torch.multiprocessing as mp
mp.spawn(fn, args=(world_size,), nprocs=world_size, join=True)
|
def get_rank() -> int:
return int(MPI.COMM_WORLD.Get_rank())
|
def get_world_size() -> int:
return int(MPI.COMM_WORLD.Get_size())
|
def get_local_rank() -> int:
return int(os.environ.get('PMI_LOCAL_RANK', os.environ.get('OMPI_COMM_WORLD_LOCAL_RANK', os.environ.get('LOCAL_RANK', '0'))))
|
def query_environment() -> dict[(str, int)]:
'Query environment variables for info about distributed setup'
ws = os.environ.get('WORLD_SIZE', None)
r = os.environ.get('RANK', None)
lr = os.environ.get('LOCAL_RANK', None)
if ((ws is not None) and (r is not None) and (lr is not None)):
retur... |
def setup_torch_DDP(port: str='2345') -> dict[(str, int)]:
import torch
rank = os.environ.get('RANK', None)
size = os.environ.get('WORLD_SIZE', None)
local_rank = os.environ.get('LOCAL_RANK', None)
import socket
size = int(get_world_size())
rank = int(get_rank())
local_rank = int(get_l... |
def setup_torch_distributed(backend: str, port: str='2345') -> dict:
import torch
rank = os.environ.get('RANK', None)
size = os.environ.get('WORLD_SIZE', None)
local_rank = os.environ.get('PMI_LOCAL_RANK', os.environ.get('OMPI_COMM_WORLD_LOCAL_RANK', None))
be = backend.lower()
assert (be in B... |
def setup_torch(seed: int, backend: str='horovod', port: str='2345', precision: Optional[str]=None) -> int:
import torch
from l2hmc.common import seed_everything
dtypes = {'float16': torch.float16, 'float32': torch.float32, 'float64': torch.float64}
os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8'
... |
def cleanup() -> None:
import torch.distributed as tdist
tdist.destroy_process_group()
|
@dataclass
class PlotObject():
ax: plt.Axes
line: list[plt.Line2D]
|
@dataclass
class LivePlotData():
data: Any
plot_obj: PlotObject
|
def moving_average(x: ArrayLike, window: int=10):
xarr = np.array(x)
if ((len(xarr.shape) > 0) and (xarr.shape[0] < window)):
return np.mean(xarr, keepdims=True)
return (np.convolve(xarr, np.ones(window), 'valid') / window)
|
def init_plots(title: Optional[str]=None, ylabels: Optional[Sequence[str]]=None, keys: Optional[Sequence[str]]=None, xlabel: str='Step', **kwargs):
set_plot_style()
plots = {}
if plt.interactive:
if ((keys is not None) and (len(keys) > 0)):
for key in keys:
plots[key] =... |
def update_plot(y: (np.ndarray | list), ax: plt.Axes, line: list[plt.Line2D], display_id: DisplayHandle, logging_steps: int=1, fig: Optional[plt.Figure]=None) -> None:
if (not is_interactive()):
return
if isinstance(y, list):
yarr: np.ndarray = (np.stack(y) if isinstance(y[0], np.ndarray) else... |
def update_joint_plots(plot_data1: LivePlotData, plot_data2: LivePlotData, display_id: DisplayHandle, logging_steps: int=1, fig: Optional[(plt.Figure | plt.FigureBase)]=None):
if (not is_interactive()):
return
plot_obj1 = plot_data1.plot_obj
plot_obj2 = plot_data2.plot_obj
y1 = np.array(plot_d... |
def init_live_plot(dpi: int=400, figsize: Optional[tuple[(int, int)]]=None, xlabel: Optional[str]=None, ylabel: Optional[str]=None, title: Optional[str]=None, **kwargs):
color = kwargs.pop('color', '#0096FF')
xlabel = ('Step' if (xlabel is None) else xlabel)
(fig, ax) = plt.subplots(nrows=1, ncols=1, dpi=... |
def init_live_joint_plots(ylabels: Sequence[str], dpi: int=120, figsize: Optional[tuple[(int, int)]]=None, xlabel: Optional[str]=None, colors: Optional[Sequence[str]]=None, title: Optional[str]=None, fig: Optional[(plt.Figure | plt.FigureBase)]=None, ax: Optional[plt.Axes]=None):
if (colors is None):
n = ... |
def update_plots(history: dict, plots: dict, logging_steps: int=1):
lpdata = PlotData(history['loss'], plots['loss']['plot_obj1'])
bpdata = PlotData(history['dQint'], plots['loss']['plot_obj2'])
fig_loss = plots['loss']['fig']
id_loss = plots['loss']['display_id']
update_joint_plots(lpdata, bpdata... |
def get_summary_writer(cfg: DictConfig, job_type: str):
'Returns SummaryWriter object for tracking summaries.'
outdir = Path(cfg.get('outdir', os.getcwd()))
jobdir = outdir.joinpath(job_type)
summary_dir = jobdir.joinpath('summaries')
summary_dir.mkdir(exist_ok=True, parents=True)
return Summa... |
def load_from_ckpt(dynamics: Dynamics, optimizer: torch.optim.Optimizer, cfg: DictConfig) -> tuple[(torch.nn.Module, torch.optim.Optimizer, dict)]:
outdir = Path(cfg.get('outdir', os.getcwd()))
if (not (ckpts := list(outdir.joinpath('train', 'checkpoints').rglob('*.tar')))):
raise FileNotFoundError(f'... |
def get_console(**kwargs) -> Console:
interactive = is_interactive()
from rich.theme import Theme
theme = Theme(STYLES)
return Console(force_jupyter=interactive, log_path=False, theme=theme, soft_wrap=True, **kwargs)
|
def is_interactive() -> bool:
from IPython.core.getipython import get_ipython
eval = (os.environ.get('INTERACTIVE', None) is not None)
bval = (get_ipython() is not None)
return (eval or bval)
|
def get_width():
width = os.environ.get('COLUMNS', os.environ.get('WIDTH', 255))
if (width is not None):
return int(width)
size = shutil.get_terminal_size()
os.environ['COLUMNS'] = str(size.columns)
return size.columns
|
def make_layout(ratio: int=4, visible: bool=True) -> Layout:
'Define the layout.'
layout = Layout(name='root', visible=visible)
layout.split_row(Layout(name='main', ratio=ratio, visible=visible), Layout(name='footer', visible=visible))
return layout
|
def build_layout(steps: Any, visible: bool=True, job_type: Optional[str]='train') -> dict:
job_progress = Progress('{task.description}', SpinnerColumn('dots'), BarColumn(), TimeElapsedColumn(), TextColumn('[progress.percentage]{task.percentage:>3.0f}%'), TimeRemainingColumn())
tasks = {}
border_style = 'w... |
def add_columns(avgs: dict, table: Table, skip: Optional[(str | list[str])]=None, keep: Optional[(str | list[str])]=None) -> Table:
for key in avgs:
if ((skip is not None) and (key in skip)):
continue
if ((keep is not None) and (key not in keep)):
continue
if (key =... |
def flatten_dict(d) -> dict:
res = {}
if isinstance(d, dict):
for k in d:
if (k == '_target_'):
continue
dflat = flatten_dict(d[k])
for (key, val) in dflat.items():
key = list(key)
key.insert(0, k)
res[... |
def nested_dict_to_df(d):
dflat = flatten_dict(d)
df = pd.DataFrame.from_dict(dflat, orient='index')
df.index = pd.MultiIndex.from_tuples(df.index)
df = df.unstack(level=(- 1))
df.columns = df.columns.map('{0[1]}'.format)
return df
|
def print_config(config: DictConfig, resolve: bool=True) -> None:
'Prints content of DictConfig using Rich library and its tree structure.\n\n Args:\n config (DictConfig): Configuration composed by Hydra.\n print_order (Sequence[str], optional): Determines in what order config\n compon... |
@dataclass
class CustomLogging():
version: int = 1
formatters: dict[(str, Any)] = field(default_factory=(lambda : {'simple': {'format': '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s'}}))
handlers: dict[(str, Any)] = field(default_factory=(lambda : {'console': {'class': 'rich.logging.RichHandler', ... |
def printarr(*arrs, float_width=6):
'\n Print a pretty table giving name, shape, dtype, type, and content\n information for input tensors or scalars.\n\n Call like: printarr(my_arr, some_other_arr, maybe_a_scalar). Accepts a\n variable number of arguments.\n\n Inputs can be:\n - Numpy tensor... |
@contextmanager
def beat(length: int=1) -> Generator:
with console:
(yield)
time.sleep((length * BEAT_TIME))
|
class DataFramePrettify():
'Create animated and pretty Pandas DataFrame.\n\n Modified from: https://github.com/khuyentran1401/rich-dataframe\n\n Parameters\n ----------\n df : pd.DataFrame\n The data you want to prettify\n row_limit : int, optional\n Number of rows to show, by default... |
def prettify(df: pd.DataFrame, row_limit: int=20, col_limit: int=10, first_rows: bool=True, first_cols: bool=True, delay_time: int=5, clear_console: bool=True):
'Create animated and pretty Pandas DataFrame\n\n Parameters\n ----------\n df : pd.DataFrame\n The data you want to prettify\n row_lim... |
def log_execution_and_time(function):
@functools.wraps(function)
def wrapper(*args, **kwargs):
NOW = get_timestamp()
start = time.time()
log.info(f'{NOW} - Start execution of: {function.__name__}')
result = function(*args, **kwargs)
end = time.time()
log.info(f... |
class BaseTimer():
def __init__(self, name: str='BaseTimer', desc: Optional[str]=None):
self.name = name
self.desc = desc
self.data: list = []
self.iterations: int = 0
self.started: float = time.time()
self._created: float = time.time()
def start(self) -> None... |
class TrainTimer():
def __init__(self) -> None:
self.step_timer = StepTimer
self.epoch_timer = StepTimer
|
class StepTimer():
def __init__(self, evals_per_step: int=1) -> None:
self.data = []
self.t = time.time()
self.iterations = 0
self.evals_per_step = evals_per_step
def start(self) -> None:
self.t = time.time()
def stop(self) -> float:
dt = (time.time() - s... |
class History(BaseHistory):
def update(self, metrics: dict) -> dict:
avgs = {}
era = metrics.get('era', 0)
for (key, val) in metrics.items():
avg = None
if isinstance(val, (float, int)):
avg = val
elif isinstance(val, dict):
... |
def get_summary_writer(cfg: DictConfig, job_type: str):
'Returns SummaryWriter object for tracking summaries.'
outdir = Path(cfg.get('outdir', os.getcwd()))
jobdir = outdir.joinpath(job_type)
sdir = jobdir.joinpath('summaries')
sdir.mkdir(exist_ok=True, parents=True)
return tf.summary.create_f... |
def evaluate(cfg: DictConfig, trainer: Trainer, job_type: str, run: Optional[Any]=None, nchains: Optional[int]=10, eps: Optional[TensorLike]=None) -> dict:
assert isinstance(nchains, int)
assert (job_type in {'eval', 'hmc'})
therm_frac = cfg.get('therm_frac', 0.2)
jobdir = get_jobdir(cfg, job_type=job... |
def train(cfg: DictConfig, trainer: Trainer, run: Optional[Any]=None, nchains: Optional[int]=None, **kwargs) -> dict:
nchains = (16 if (nchains is None) else nchains)
jobdir = get_jobdir(cfg, job_type='train')
writer = get_summary_writer(cfg, job_type='train')
if (writer is not None):
writer.s... |
def GetCOCOCatNames():
ClassNames = {}
ClassNames[0] = 'person'
ClassNames[1] = 'bicycle'
ClassNames[2] = 'car'
ClassNames[3] = 'motorcycle'
ClassNames[4] = 'airplane'
ClassNames[5] = 'bus'
ClassNames[6] = 'train'
ClassNames[7] = 'truck'
ClassNames[8] = 'boat'
ClassNames[9]... |
@app.route('/')
def home():
return render_template('index.html')
|
@app.route('/predict', methods=['POST'])
def predict():
'\n For rendering results on HTML GUI\n '
st = [str(x) for x in request.form.values()]
prediction = recommend(st[0])
pr = ((((((('1) ' + prediction[0][0]) + ' // ') + '2) ') + prediction[0][1]) + ' // ') + '3) ') + prediction[0][2])
ret... |
@app.route('/predict_api', methods=['POST'])
def predict_api():
'\n For direct API calls trought request\n '
data = request.get_json(force=True)
prediction = recommend(data)
output = prediction[0][0]
return jsonify(output)
|
def recommend(abstract: str):
from simpletransformers.t5 import T5Model
model_args = {'reprocess_input_data': True, 'overwrite_output_dir': True, 'max_seq_length': 256, 'eval_batch_size': 128, 'num_train_epochs': 1, 'save_eval_checkpoints': False, 'use_multiprocessing': False, 'num_beams': None, 'do_sample': ... |
def getMetadata(path_to_json):
with open(path_to_json, 'r') as f:
for line in f:
(yield line)
|
def json2list(path_to_json):
metadata = getMetadata(path_to_json)
generator_iter = next(metadata)
keys = json.loads(generator_iter)
abstracts = []
titles = []
years = []
categories = []
authors = []
authors_parsed = []
for paper in metadata:
paper_dict = json.loads(pape... |
def json2csv(path_to_json):
data = json2list(path_to_json)
df_all = pd.DataFrame({'Title': data['titles'], 'Abstract': data['abstracts'], 'Parsed Authors': data['authors_parsed'], 'Authors': data['authors'], 'Year': data['years'], 'Category': data['categories']})
df_all.to_csv('../data/raw.csv', index=Fal... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.