code stringlengths 17 6.64M |
|---|
def main(argv=None):
tf.reset_default_graph()
keep_prob = tf.placeholder(tf.float32, name='keep_probabilty')
image = tf.placeholder(tf.float32, shape=[None, None, None, 3], name='input_image')
GTLabel = tf.placeholder(tf.int32, shape=[None, None, None, 1], name='GTLabel')
Net = BuildNetVgg16.BUILD... |
def get_model_data(dir_path, model_url):
maybe_download_and_extract(dir_path, model_url)
filename = model_url.split('/')[(- 1)]
filepath = os.path.join(dir_path, filename)
if (not os.path.exists(filepath)):
raise IOError('VGG Model not found!')
data = scipy.io.loadmat(filepath)
return ... |
def maybe_download_and_extract(dir_path, url_name, is_tarfile=False, is_zipfile=False):
if (not os.path.exists(dir_path)):
os.makedirs(dir_path)
filename = url_name.split('/')[(- 1)]
filepath = os.path.join(dir_path, filename)
if (not os.path.exists(filepath)):
def _progress(count, bl... |
def save_image(image, save_dir, name, mean=None):
'\n Save image by unprocessing if mean given else just save\n :param mean:\n :param image:\n :param save_dir:\n :param name:\n :return:\n '
if mean:
image = unprocess_image(image, mean)
misc.imsave(os.path.join(save_dir, (name ... |
def get_variable(weights, name):
init = tf.constant_initializer(weights, dtype=tf.float32)
var = tf.get_variable(name=name, initializer=init, shape=weights.shape)
return var
|
def weight_variable(shape, stddev=0.02, name=None):
initial = tf.truncated_normal(shape, stddev=stddev)
if (name is None):
return tf.Variable(initial)
else:
return tf.get_variable(name, initializer=initial)
|
def bias_variable(shape, name=None):
initial = tf.constant(0.0, shape=shape)
if (name is None):
return tf.Variable(initial)
else:
return tf.get_variable(name, initializer=initial)
|
def get_tensor_size(tensor):
from operator import mul
return reduce(mul, (d.value for d in tensor.get_shape()), 1)
|
def conv2d_basic(x, W, bias):
conv = tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
return tf.nn.bias_add(conv, bias)
|
def conv2d_strided(x, W, b):
conv = tf.nn.conv2d(x, W, strides=[1, 2, 2, 1], padding='SAME')
return tf.nn.bias_add(conv, b)
|
def conv2d_transpose_strided(x, W, b, output_shape=None, stride=2):
if (output_shape is None):
output_shape = x.get_shape().as_list()
output_shape[1] *= 2
output_shape[2] *= 2
output_shape[3] = W.get_shape().as_list()[2]
conv = tf.nn.conv2d_transpose(x, W, output_shape, strides... |
def leaky_relu(x, alpha=0.0, name=''):
return tf.maximum((alpha * x), x, name)
|
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
|
def avg_pool_2x2(x):
return tf.nn.avg_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
|
def local_response_norm(x):
return tf.nn.lrn(x, depth_radius=5, bias=2, alpha=0.0001, beta=0.75)
|
def batch_norm(x, n_out, phase_train, scope='bn', decay=0.9, eps=1e-05):
'\n Code taken from http://stackoverflow.com/a/34634291/2267819\n '
with tf.variable_scope(scope):
beta = tf.get_variable(name='beta', shape=[n_out], initializer=tf.constant_initializer(0.0), trainable=True)
gamma =... |
def process_image(image, mean_pixel):
return (image - mean_pixel)
|
def unprocess_image(image, mean_pixel):
return (image + mean_pixel)
|
def bottleneck_unit(x, out_chan1, out_chan2, down_stride=False, up_stride=False, name=None):
'\n Modified implementation from github ry?!\n '
def conv_transpose(tensor, out_channel, shape, strides, name=None):
out_shape = tensor.get_shape().as_list()
in_channel = out_shape[(- 1)]
... |
def add_to_regularization_and_summary(var):
if (var is not None):
tf.summary.histogram(var.op.name, var)
tf.add_to_collection('reg_loss', tf.nn.l2_loss(var))
|
def add_activation_summary(var):
if (var is not None):
tf.summary.histogram((var.op.name + '/activation'), var)
tf.summary.scalar((var.op.name + '/sparsity'), tf.nn.zero_fraction(var))
|
def add_gradient_summary(grad, var):
if (grad is not None):
tf.summary.histogram((var.op.name + '/gradient'), grad)
|
def dict_to_list_of_overrides(d: dict):
return [f'{k}={v}' for (k, v) in flatten_dict(d, sep='.').items()]
|
def flatten_dict(d: dict, sep: str='/', pre='') -> dict:
return ({(((pre + sep) + k) if pre else k): v for (kk, vv) in d.items() for (k, v) in flatten_dict(vv, sep, kk).items()} if isinstance(d, dict) else {pre: d})
|
def add_to_outdirs_file(outdir: os.PathLike):
with open(OUTDIRS_FILE, 'a') as f:
f.write((Path(outdir).resolve.as_posix() + '\n'))
|
def get_jobdir(cfg: DictConfig, job_type: str) -> Path:
jobdir = Path(cfg.get('outdir', os.getcwd())).joinpath(job_type)
jobdir.mkdir(exist_ok=True, parents=True)
assert (jobdir is not None)
add_to_outdirs_file(jobdir)
return jobdir
|
def list_to_str(x: list) -> str:
if isinstance(x[0], int):
return '-'.join([str(int(i)) for i in x])
elif isinstance(x[0], float):
return '-'.join([f'{i:2.1f}' for i in x])
else:
return '-'.join([str(i) for i in x])
|
@dataclass
class State():
x: Any
v: Any
beta: Any
|
@dataclass
@rich.repr.auto
class BaseConfig(ABC):
@abstractmethod
def to_str(self) -> str:
pass
def to_json(self) -> str:
return json.dumps(self.__dict__)
def get_config(self) -> dict:
return asdict(self)
def asdict(self) -> dict:
return asdict(self)
def to... |
@dataclass
class Charges():
intQ: Any
sinQ: Any
|
@dataclass
class LatticeMetrics():
plaqs: Any
charges: Charges
p4x4: Any
def asdict(self) -> dict:
return {'plaqs': self.plaqs, 'sinQ': self.charges.sinQ, 'intQ': self.charges.intQ, 'p4x4': self.p4x4}
|
@dataclass
class EnvConfig():
def __post_init__(self):
import socket
dist_env = udist.query_environment()
self.rank = dist_env['rank']
self.local_rank = dist_env['local_rank']
self.world_size = dist_env['world_size']
try:
self.hostname = socket.gethostn... |
@dataclass
class wandbSetup(BaseConfig):
id: Optional[str] = None
group: Optional[str] = None
save_code: Optional[bool] = True
sync_tensorboard: Optional[bool] = True
tags: Optional[Sequence[str]] = None
mode: Optional[str] = 'online'
resume: Optional[str] = 'allow'
entity: Optional[st... |
@dataclass
class wandbConfig(BaseConfig):
setup: wandbSetup
def to_str(self) -> str:
return self.to_json()
|
@dataclass
class NetWeight(BaseConfig):
'Object for selectively scaling different components of learned fns.\n\n Explicitly,\n - s: scales the v (x) scaling function in the v (x) updates\n - t: scales the translation function in the update\n - q: scales the force (v) transformation function in the ... |
@dataclass
class NetWeights(BaseConfig):
'Object for selectively scaling different components of x, v networks.'
x: NetWeight = NetWeight(1.0, 1.0, 1.0)
v: NetWeight = NetWeight(1.0, 1.0, 1.0)
def to_str(self):
return f'nwx-{self.x.to_str()}-nwv-{self.v.to_str()}'
def to_dict(self):
... |
@dataclass
class LearningRateConfig(BaseConfig):
'Learning rate configuration object.'
lr_init: float = 0.001
mode: str = 'auto'
monitor: str = 'loss'
patience: int = 5
cooldown: int = 0
warmup: int = 1000
verbose: bool = True
min_lr: float = 1e-06
factor: float = 0.98
min_... |
@dataclass
class Steps(BaseConfig):
nera: int
nepoch: int
test: int
log: int = 100
print: int = 200
extend_last_era: Optional[int] = None
def __post_init__(self):
if (self.extend_last_era is None):
self.extend_last_era = 1
self.total = (self.nera * self.nepoch)... |
@dataclass
class ConvolutionConfig(BaseConfig):
filters: Optional[Sequence[int]] = None
sizes: Optional[Sequence[int]] = None
pool: Optional[Sequence[int]] = None
def __post_init__(self):
if (self.filters is None):
return
if (self.sizes is None):
logger.warning... |
@dataclass
class NetworkConfig(BaseConfig):
units: Sequence[int]
activation_fn: str
dropout_prob: float
use_batch_norm: bool = True
def to_str(self):
ustr = '-'.join([str(int(i)) for i in self.units])
dstr = f'dp-{self.dropout_prob:2.1f}'
bstr = f'bn-{self.use_batch_norm}'... |
@dataclass
class DynamicsConfig(BaseConfig):
nchains: int
group: str
latvolume: List[int]
nleapfrog: int
eps: float = 0.01
eps_hmc: float = 0.01
use_ncp: bool = True
verbose: bool = True
eps_fixed: bool = False
use_split_xnets: bool = True
use_separate_networks: bool = True... |
@dataclass
class LossConfig(BaseConfig):
use_mixed_loss: bool = False
charge_weight: float = 0.01
rmse_weight: float = 0.0
plaq_weight: float = 0.0
aux_weight: float = 0.0
def to_str(self) -> str:
return '_'.join([f'qw-{self.charge_weight:2.1f}', f'pw-{self.plaq_weight:2.1f}', f'rw-{s... |
@dataclass
class InputSpec(BaseConfig):
xshape: Sequence[int]
xnet: Optional[Dict[(str, (int | Sequence[int]))]] = None
vnet: Optional[Dict[(str, (int | Sequence[int]))]] = None
def to_str(self):
return '-'.join([str(i) for i in self.xshape])
def __post_init__(self):
if (len(self... |
@dataclass
class FlopsProfiler():
enabled: bool = False
profile_step: int = 1
module_depth: int = (- 1)
top_modules: int = 1
detailed: bool = True
output_file: Optional[((os.PathLike | str) | Path)] = None
def __post_init__(self):
pass
|
@dataclass
class OptimizerConfig():
type: str
params: Optional[dict] = field(default_factory=dict)
|
@dataclass
class fp16Config():
enabled: bool
auto_cast: bool = True
fp16_master_weights_and_grads: bool = False
min_loss_scale: float = 0.0
|
@dataclass
class CommsLogger():
enabled: bool
verbose: bool = True
prof_all: bool = True
debug: bool = False
|
@dataclass
class AutoTuning():
enabled: bool
arg_mappings: Optional[dict] = field(default_factory=dict)
|
@dataclass
class ZeroOptimization():
stage: int
|
@dataclass
class ExperimentConfig(BaseConfig):
wandb: Any
steps: Steps
framework: str
loss: LossConfig
network: NetworkConfig
conv: ConvolutionConfig
net_weights: NetWeights
dynamics: DynamicsConfig
learning_rate: LearningRateConfig
annealing_schedule: AnnealingSchedule
gra... |
@dataclass
class AnnealingSchedule(BaseConfig):
beta_init: float
beta_final: Optional[float] = 1.0
dynamic: bool = False
def to_str(self) -> str:
return f'bi-{self.beta_init}_bf-{self.beta_final}'
def __post_init__(self):
if ((self.beta_final is None) or (self.beta_final < self.b... |
@dataclass
class Annealear():
'Dynamically adjust annealing schedule during training.'
schedule: AnnealingSchedule
patience: int
min_delta: Optional[float] = None
def __post_init__(self):
self.wait = 0
self.best = np.Inf
self._current_era = 0
self._current_beta = s... |
def get_config(overrides: Optional[list[str]]=None):
from hydra import initialize_config_dir, compose
from hydra.core.global_hydra import GlobalHydra
GlobalHydra.instance().clear()
overrides = ([] if (overrides is None) else overrides)
with initialize_config_dir(CONF_DIR.absolute().as_posix(), ver... |
def get_experiment(overrides: Optional[list[str]]=None, build_networks: bool=True, keep: Optional[(str | list[str])]=None, skip: Optional[(str | list[str])]=None):
cfg = get_config(overrides)
if (cfg.framework == 'pytorch'):
from l2hmc.experiment.pytorch.experiment import Experiment
return Exp... |
@dataclass
class DiffusionConfig():
'\n Diffusion Config.\n\n Args:\n - `log_likelihood_fn`: Callable[[torch.Tensor], torch.Tensor]:\n - Your log-likelihood function to be sampled. Must be defined in\n terms of a 1D parameter array `x` and a number of dimensions\n ... |
class DummyTqdmFile(object):
' Dummy file-like that will write to tqdm\n https://github.com/tqdm/tqdm/issues/313\n '
file = None
def __init__(self, file):
self.file = file
def write(self, x):
tqdm.tqdm.write(x, file=self.file, end='\n')
def flush(self):
return geta... |
def get_rich_logger(name: Optional[str]=None, level: str='INFO') -> logging.Logger:
log = logging.getLogger(name)
log.handlers = []
from l2hmc.utils.rich import get_console
console = get_console(markup=True, redirect=(WORLD_SIZE > 1))
handler = RichHandler(level, rich_tracebacks=False, console=con... |
def get_file_logger(name: Optional[str]=None, level: str='INFO', rank_zero_only: bool=True, fname: Optional[str]=None) -> logging.Logger:
import logging
fname = ('l2hmc' if (fname is None) else fname)
log = logging.getLogger(name)
if rank_zero_only:
fh = logging.FileHandler(f'{fname}.log')
... |
def get_logger(name: Optional[str]=None, level: str='INFO', rank_zero_only: bool=True, **kwargs) -> logging.Logger:
log = logging.getLogger(name)
from l2hmc.utils.rich import get_console, is_interactive
if rank_zero_only:
if (RANK != 0):
log.setLevel('CRITICAL')
else:
... |
def get_experiment(cfg: DictConfig, keep: Optional[(str | list[str])]=None, skip: Optional[(str | list[str])]=None):
framework = cfg.get('framework', None)
os.environ['RUNDIR'] = os.getcwd()
if (framework in ['tf', 'tensorflow']):
cfg.framework = 'tensorflow'
from ezpz import setup_tensorf... |
def run(cfg: DictConfig, overrides: Optional[list[str]]=None) -> str:
from l2hmc.utils.plot_helpers import set_plot_style
set_plot_style()
import matplotlib.pyplot as plt
import opinionated
plt.style.use(opinionated.STYLES['opinionated_min'])
if (overrides is not None):
from l2hmc.conf... |
def build_experiment(overrides: Optional[(str | list[str])]=None):
import warnings
warnings.filterwarnings('ignore')
from l2hmc.configs import get_config
if isinstance(overrides, str):
overrides = [overrides]
cfg = get_config(overrides)
return get_experiment(cfg=cfg)
|
@hydra.main(version_base=None, config_path='./conf', config_name='config')
def main(cfg: DictConfig):
output = run(cfg)
fw = cfg.get('framework', None)
be = cfg.get('backend', None)
if ((str(fw).lower() in {'pt', 'torch', 'pytorch'}) and (str(be).lower() == 'ddp')):
from l2hmc.utils.dist impor... |
def grab_tensor(x: Any) -> ((np.ndarray | ScalarLike) | None):
if (x is None):
return None
if isinstance(x, (int, float, bool, np.floating)):
return x
if isinstance(x, list):
if isinstance(x[0], torch.Tensor):
return grab_tensor(torch.stack(x))
elif isinstance(x... |
def dict_to_str(d: dict, grab: Optional[bool]=None) -> str:
if grab:
return '\n'.join([f'''{k}: {getattr(v, 'shape', None)} {getattr(v, 'dtype', None)}
{grab_tensor(v)}''' for (k, v) in d.items()])
return '\n'.join([f'{k}: {v}' for (k, v) in d.items()])
|
def print_dict(d: dict, grab: Optional[bool]=None, ret: Optional[bool]=None) -> (str | None):
dstr = dict_to_str(d, grab=grab)
log.info(dstr)
return (dstr if ret else None)
|
def clear_cuda_cache():
import gc
gc.collect()
with torch.no_grad():
torch.cuda.empty_cache()
torch.clear_autocast_cache()
|
def get_timestamp(fstr=None):
'Get formatted timestamp.'
now = datetime.datetime.now()
return (now.strftime('%Y-%m-%d-%H%M%S') if (fstr is None) else now.strftime(fstr))
|
def seed_everything(seed: int):
import random
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
|
def check_diff(x: Any, y: Any, name: Optional[str]=None) -> np.ndarray:
if isinstance(x, State):
xd = {'x': x.x, 'v': x.v, 'beta': x.beta}
yd = {'x': y.x, 'v': y.v, 'beta': y.beta}
check_diff(xd, yd, name='State')
elif (isinstance(x, dict) and isinstance(y, dict)):
for ((kx, vx... |
def update_dict(dnew: dict, dold: Optional[dict]=None) -> tuple[(list[str], dict)]:
import torch
import tensorflow as tf
dold = ({} if (dold is None) else dold)
mstr = []
for (key, val) in dnew.items():
if isinstance(val, (torch.Tensor, tf.Tensor)):
val = grab_tensor(val)
... |
def setup_annealing_schedule(cfg: DictConfig) -> AnnealingSchedule:
steps = Steps(**cfg.steps)
beta_init = cfg.get('beta_init', None)
beta_final = cfg.get('beta_final', None)
if (beta_init is None):
beta_init = 1.0
log.warn(f'beta_init not specified!using default: beta_init = {beta_ini... |
def save_dataset(dataset: xr.Dataset, outdir: os.PathLike, use_hdf5: Optional[bool]=True, job_type: Optional[str]=None, **kwargs) -> Path:
if use_hdf5:
fname = ('dataset.h5' if (job_type is None) else f'{job_type}_data.h5')
outfile = Path(outdir).joinpath(fname)
try:
dataset_to... |
def dataset_to_h5pyfile(hfile: os.PathLike, dataset: xr.Dataset, **kwargs):
log.info(f'Saving dataset to: {hfile}')
f = h5py.File(hfile, 'a')
for (key, val) in dataset.data_vars.items():
arr = val.values
if (len(arr) == 0):
continue
if (key in list(f.keys())):
... |
def dict_from_h5pyfile(hfile: os.PathLike) -> dict:
f = h5py.File(hfile, 'r')
data = {key: f[key] for key in list(f.keys())}
f.close()
return data
|
def dataset_from_h5pyfile(hfile: os.PathLike) -> xr.Dataset:
f = h5py.File(hfile, 'r')
data = {key: f[key] for key in list(f.keys())}
f.close()
return xr.Dataset(data)
|
def load_job_data(logdir: os.PathLike, jobtype: str) -> xr.Dataset:
assert (jobtype in {'train', 'eval', 'hmc'})
fpath = Path(logdir).joinpath(f'{jobtype}', 'data', f'{jobtype}_data.h5')
assert fpath.is_file()
return dataset_from_h5pyfile(fpath)
|
def load_time_data(logdir: os.PathLike, jobtype: str) -> pd.DataFrame:
assert (jobtype in {'train', 'eval', 'hmc'})
fpaths = Path(logdir).rglob(f'step-timer-{jobtype}')
data = {}
for (idx, fpath) in enumerate(fpaths):
tdata = pd.read_csv(fpath)
data[f'{idx}'] = tdata
return pd.Data... |
def _load_from_dir(logdir: os.PathLike, to_load: str) -> (xr.Dataset | pd.DataFrame):
if (to_load in {'train', 'eval', 'hmc'}):
return load_job_data(logdir=logdir, jobtype=to_load)
if (to_load in {'time', 'timing'}):
return load_time_data(logdir, jobtype=to_load)
raise ValueError('Unexpect... |
def load_from_dir(logdir: os.PathLike, to_load: (str | list[str])) -> dict[(str, xr.Dataset)]:
assert (to_load in ['train', 'eval', 'hmc', 'time', 'timing'])
data = {}
if isinstance(to_load, list):
for i in to_load:
data[i] = _load_from_dir(logdir, to_load)
elif isinstance(to_load,... |
def latvolume_to_str(latvolume: list[int]):
return 'x'.join([str(i) for i in latvolume])
|
def check_nonempty(fpath: os.PathLike) -> bool:
return (Path(fpath).is_dir() and (len(os.listdir(fpath)) > 0))
|
def check_jobdir(fpath: os.PathLike) -> bool:
jobdir = Path(fpath)
pdir = jobdir.joinpath('plots')
ddir = jobdir.joinpath('data')
ldir = jobdir.joinpath('logs')
return (check_nonempty(pdir) and check_nonempty(ddir) and check_nonempty(ldir))
|
def check_if_logdir(fpath: os.PathLike) -> bool:
logdir = Path(fpath)
contents = os.listdir(logdir)
contents = os.listdir(logdir)
in_contents = (('train' in contents) and ('eval' in contents) and ('hmc' in contents))
non_empty = (check_nonempty(logdir.joinpath('train')) and check_nonempty(logdir.j... |
def check_if_matching_logdir(fpath: os.PathLike, config_str: str) -> bool:
return (check_if_logdir(fpath) and (config_str in Path(fpath).as_posix()))
|
def find_logdirs(rootdir: os.PathLike) -> list[Path]:
'Every `logdir` should contain a `config_tree.log` file.'
return [Path(i).parent for i in Path(rootdir).rglob('config_tree.log') if check_if_logdir(Path(i).parent)]
|
def _match_beta(logdir, beta: Optional[float]=None) -> bool:
return ((beta is not None) and (f'beta-{beta:.1f}' in Path(logdir).as_posix()))
|
def _match_group(logdir, group: Optional[str]=None) -> bool:
return ((group is not None) and (group in Path(logdir).as_posix()))
|
def _match_nlf(logdir, nlf: Optional[int]=None) -> bool:
return ((nlf is not None) and (f'nlf-{nlf}' in Path(logdir).as_posix()))
|
def _match_merge_directions(logdir, merge_directions: Optional[bool]=None) -> bool:
return ((merge_directions is not None) and (f'merge_directions-{merge_directions}' in Path(logdir).as_posix()))
|
def _match_framework(logdir: os.PathLike, framework: Optional[str]=None) -> bool:
return ((framework is not None) and (framework in Path(logdir).as_posix()))
|
def _match_latvolume(logdir: os.PathLike, latvolume: Optional[list[int]]=None) -> bool:
return ((latvolume is not None) and ('x'.join([str(i) for i in latvolume]) in Path(logdir).as_posix()))
|
def filter_logdirs(logdirs: list, beta: Optional[float]=None, group: Optional[str]=None, nlf: Optional[int]=None, merge_directions: Optional[bool]=None, framework: Optional[str]=None, latvolume: Optional[list[int]]=None) -> list[os.PathLike]:
'Filter logdirs by criteria.'
matches = []
for logdir in logdir... |
def find_matching_logdirs(rootdir: os.PathLike, beta: Optional[float]=None, group: Optional[str]=None, nlf: Optional[int]=None, merge_directions: Optional[bool]=None, framework: Optional[str]=None, latvolume: Optional[list[int]]=None):
logdirs = find_logdirs(rootdir)
return filter_logdirs(logdirs, beta=beta, ... |
def find_runs_with_matching_options(config: dict[(str, Any)], rootdir: Optional[os.PathLike]=None) -> list[Path]:
'Find runs with options matching those specified in `config`.'
if (rootdir is None):
rootdir = Path(OUTPUTS_DIR)
config_files = [i.resolve() for i in Path(rootdir).rglob('*.yaml') if (... |
def table_to_dict(table: Table, data: Optional[dict]=None) -> dict:
if (data is None):
return {column.header: [float(i) for i in list(column.cells)] for column in table.columns}
for column in table.columns:
try:
data[column.header].extend([float(i) for i in list(column.cells)])
... |
def save_logs(tables: Optional[dict[(str, Table)]]=None, summaries: Optional[list[str]]=None, job_type: Optional[str]=None, logdir: Optional[os.PathLike]=None, run: Optional[Any]=None, rank: Optional[int]=None) -> None:
job_type = ('job' if (job_type is None) else job_type)
logdir = (Path(os.getcwd()).joinpat... |
def make_subdirs(basedir: os.PathLike):
dirs = {}
assert Path(basedir).is_dir()
for key in ['logs', 'data', 'plots']:
d = Path(basedir).joinpath(key)
d.mkdir(exist_ok=True, parents=True)
dirs[key] = d
return dirs
|
def save_figure(fig: plt.Figure, key: str, outdir: os.PathLike):
pngdir = Path(outdir).joinpath('pngs')
svgdir = Path(outdir).joinpath('svgs')
pngdir.mkdir(parents=True, exist_ok=True)
svgdir.mkdir(parents=True, exist_ok=True)
svgfile = svgdir.joinpath(f'{key}.svg')
pngfile = pngdir.joinpath(f... |
def savefig(fname: str, outdir: os.PathLike, tstamp: Optional[bool]=True):
outdir = Path(outdir)
if tstamp:
fname = f"{fname}-{get_timestamp('%Y-%m-%d-%H%M%S')}"
print(f'Saving {fname} to {outdir}')
for ext in {'png', 'svg'}:
edir = Path(outdir).joinpath(f'{ext}s')
edir.mkdir(e... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.