code stringlengths 17 6.64M |
|---|
def get_wav_time_len(filename):
'\n :param str filename:\n :rtype: float\n '
f = wave.open(filename)
num_frames = f.getnframes()
frame_rate = f.getframerate()
f.close()
return (num_frames / float(frame_rate))
|
def iter_bliss(filename, options, callback):
corpus_file = open(filename, 'rb')
if filename.endswith('.gz'):
corpus_file = gzip.GzipFile(fileobj=corpus_file)
def getelements(tag):
'Yield *tag* elements from *filename_or_file* xml incrementaly.'
context = iter(ElementTree.iterparse... |
def iter_txt(filename, options, callback):
f = open(filename, 'rb')
if filename.endswith('.gz'):
f = gzip.GzipFile(fileobj=f)
if options.collect_time:
print('No time-info in txt.', file=log.v3)
options.collect_time = False
for line in f:
line = line.strip()
if (... |
def collect_stats(options, iter_corpus):
'\n :param options: argparse.Namespace\n '
orth_symbols_filename = options.output
if orth_symbols_filename:
assert (not os.path.exists(orth_symbols_filename))
class Stats():
count = 0
process_last_time = time.time()
total_... |
def init(config_filename=None):
rnn.init_better_exchook()
rnn.init_thread_join_hack()
if config_filename:
rnn.init_config(config_filename, command_line_options=[])
rnn.init_log()
else:
log.initialize()
print('RETURNN collect-orth-symbols starting up.', file=log.v3)
rnn.... |
def is_bliss(filename):
try:
corpus_file = open(filename, 'rb')
if filename.endswith('.gz'):
corpus_file = gzip.GzipFile(fileobj=corpus_file)
context = iter(ElementTree.iterparse(corpus_file, events=('start', 'end')))
(_, root) = next(context)
return True
ex... |
def is_crnn_config(filename):
if filename.endswith('.gz'):
return False
try:
config = Config()
config.load_file(filename)
return True
except Exception:
pass
return False
|
def main(argv):
argparser = argparse.ArgumentParser(description='Collect orth symbols.')
argparser.add_argument('input', help='RETURNN config, Corpus Bliss XML or just txt-data')
argparser.add_argument('--frame_time', type=int, default=10, help='time (in ms) per frame. not needed for Corpus Bliss XML')
... |
def iter_dataset(dataset, callback):
'\n :param Dataset.Dataset dataset:\n :param (*)->None callback:\n '
dataset.init_seq_order(epoch=1)
assert ('orth' in dataset.get_target_list())
seq_idx = 0
while dataset.is_less_than_num_seqs(seq_idx):
dataset.load_seqs(seq_idx, seq_idx)
... |
def iter_bliss(filename, callback):
'\n Iterate through a Sprint Bliss XML file.\n\n :param str filename:\n :param callback:\n '
corpus_file = open(filename, 'rb')
if filename.endswith('.gz'):
corpus_file = gzip.GzipFile(fileobj=corpus_file)
def get_elements(tag):
'Yield *... |
def iter_txt(filename, callback):
'\n Iterate through pure text file.\n\n :param str filename:\n :param callback:\n '
f = open(filename, 'rb')
if filename.endswith('.gz'):
f = gzip.GzipFile(fileobj=f)
for line in f:
line = line.strip()
if (not line):
con... |
class CollectCorpusStats():
'\n Collect stats.\n '
def __init__(self, options, iter_corpus):
'\n :param options: argparse.Namespace\n :param iter_corpus:\n '
self.options = options
self.seq_count = 0
self.words = set()
self.total_word_len = 0... |
def init(config_filename=None):
'\n :param str config_filename:\n '
rnn.init_better_exchook()
rnn.init_thread_join_hack()
if config_filename:
rnn.init_config(config_filename, command_line_options=[])
rnn.init_log()
else:
log.initialize()
print('Returnn collect-wor... |
def is_bliss(filename):
'\n :param str filename:\n :rtype: bool\n '
try:
corpus_file = open(filename, 'rb')
if filename.endswith('.gz'):
corpus_file = gzip.GzipFile(fileobj=corpus_file)
context = iter(ElementTree.iterparse(corpus_file, events=('start', 'end')))
... |
def is_returnn_config(filename):
'\n :param str filename:\n :rtype: bool\n '
if filename.endswith('.gz'):
return False
try:
config = Config()
config.load_file(filename)
return True
except Exception:
pass
return False
|
def main(argv):
'\n Main entry.\n '
arg_parser = argparse.ArgumentParser(description='Collect orth symbols.')
arg_parser.add_argument('input', help='RETURNN config, Corpus Bliss XML or just txt-data')
arg_parser.add_argument('--dump_orth', action='store_true')
arg_parser.add_argument('--lexi... |
def init(config_filename, log_verbosity):
'\n :param str config_filename: filename to config-file\n :param int log_verbosity:\n '
rnn.init_better_exchook()
rnn.init_thread_join_hack()
if config_filename:
print(('Using config file %r.' % config_filename))
assert os.path.exists(... |
def main(argv):
'\n Main entry.\n '
from returnn.tf.util.basic import CudaEnv, OpCodeCompiler
CudaEnv.verbose_find_cuda = True
OpCodeCompiler.CollectedCompilers = []
argparser = argparse.ArgumentParser(description='Compile some op')
argparser.add_argument('--config', help='filename to co... |
def init(config_filename, log_verbosity, device):
'\n :param str config_filename: filename to config-file\n :param int log_verbosity:\n :param str device:\n '
rnn.init_better_exchook()
rnn.init_thread_join_hack()
print(('Using config file %r.' % config_filename))
assert os.path.exists(... |
def create_graph(train_flag, eval_flag, search_flag, net_dict):
'\n :param bool train_flag:\n :param bool eval_flag:\n :param bool search_flag:\n :param dict[str,dict[str]] net_dict:\n :return: adds to the current graph, and then returns the network\n :rtype: returnn.tf.network.TFNetwork\n '
... |
@contextlib.contextmanager
def helper_variable_scope():
'\n :return: separate scope from the current name scope, such that variables are not treated as model params\n :rtype: tf.VariableScope\n '
with tf_util.reuse_name_scope('IO', absolute=True) as scope:
(yield scope)
|
class SubnetworkRecCellSingleStep(_SubnetworkRecCell):
'\n Adapts :class:`_SubnetworkRecCell` such that we execute only a single step.\n Used by :class:`RecStepByStepLayer`. See :class:`RecStepByStepLayer` for further documentation.\n '
def __init__(self, **kwargs):
self._parent_layers = {}
... |
class RecStepByStepLayer(RecLayer):
'\n Represents a single step of :class:`RecLayer`.\n The purpose is to execute a single step only.\n This also takes care of all needed state, and stochastic (maybe latent) variables (via :class:`ChoiceLayer`).\n All the state is kept in *state variables*, such that... |
class ChoiceStateVarLayer(LayerBase):
"\n Like :class:`ChoiceLayer`, but we don't do the search/choice ourselves,\n instead we store the scores in a variable, and the final result is another variable,\n which is expected to be set externally.\n This is expected to be used together with :class:`RecStep... |
def main(argv):
'\n Main entry.\n '
argparser = argparse.ArgumentParser(description='Compile some op')
argparser.add_argument('config', help='filename to config-file')
argparser.add_argument('--epoch', type=int, default=None, help='specific epoch to construct, use for dynamic network definitions... |
def init(config_filename, log_verbosity, remaining_args=()):
'\n :param str config_filename: filename to config-file\n :param int log_verbosity:\n :param list[str] remaining_args:\n '
rnn.init_better_exchook()
rnn.init_thread_join_hack()
print(('Using config file %r.' % config_filename))
... |
def prepare_compile(rec_layer_name, net_dict, cheating, dump_att_weights, hdf_filename, possible_labels):
'\n :param str rec_layer_name:\n :param dict[str] net_dict: modify inplace\n :param bool cheating:\n :param bool dump_att_weights:\n :param str hdf_filename:\n :param dict[str,list[str]] pos... |
def main(argv):
'\n Main entry.\n '
arg_parser = argparse.ArgumentParser(description='Dump search scores and other info to HDF file.')
arg_parser.add_argument('config', help='filename to config-file')
arg_parser.add_argument('--dataset', default='config:train')
arg_parser.add_argument('--epo... |
def get_raw_strings(dataset, options):
'\n :param Dataset dataset:\n :param options: argparse.Namespace\n :return: list of (seq tag, string)\n :rtype: list[(str,str)]\n '
refs = []
start_time = time.time()
seq_len_stats = Stats()
seq_idx = options.startseq
if (options.endseq < 0... |
def init(config_filename, log_verbosity):
'\n :param str config_filename: filename to config-file\n :param int log_verbosity:\n '
rnn.init_better_exchook()
rnn.init_thread_join_hack()
if config_filename:
print(('Using config file %r.' % config_filename))
assert os.path.exists(... |
def generic_open(filename, mode='r'):
'\n :param str filename:\n :param str mode: text mode by default\n :rtype: typing.TextIO|typing.BinaryIO\n '
if filename.endswith('.gz'):
import gzip
if ('b' not in mode):
mode += 't'
return gzip.open(filename, mode)
ret... |
def main(argv):
'\n Main entry.\n '
arg_parser = argparse.ArgumentParser(description='Dump raw strings from dataset. Same format as in search.')
arg_parser.add_argument('--config', help="filename to config-file. will use dataset 'eval' from it")
arg_parser.add_argument('--dataset', help='dataset... |
def plot(m):
'\n :param numpy.ndarray m:\n '
print(('Plotting matrix of shape %s.' % (m.shape,)))
from matplotlib.pyplot import matshow, show
matshow(m.transpose())
show()
|
def dump_dataset(options):
'\n :param options: argparse.Namespace\n '
print(('Epoch: %i' % options.epoch), file=log.v3)
seq_list = None
if options.seqtags:
seq_list = options.seqtags.split(',')
dataset.init_seq_order(epoch=options.epoch, seq_list=seq_list)
print('Dataset keys:', ... |
def init(config_str, config_dataset, verbosity):
'\n :param str config_str: either filename to config-file, or dict for dataset\n :param str|None config_dataset:\n :param int verbosity:\n '
global dataset
rnn.init_better_exchook()
rnn.init_thread_join_hack()
dataset_dict = None
con... |
def main():
'\n Main entry.\n '
argparser = argparse.ArgumentParser(description='Dump something from dataset.')
argparser.add_argument('returnn_config', help='either filename to config-file, or dict for dataset')
argparser.add_argument('--dataset', help="if given the config, specifies the datase... |
def dump(dataset, options):
'\n :type dataset: Dataset.Dataset\n :param options: argparse.Namespace\n '
print(('Epoch: %i' % options.epoch), file=log.v3)
dataset.init_seq_order(options.epoch)
output_dict = {}
for (name, layer) in rnn.engine.network.layers.items():
output_dict[('%s... |
def init(config_filename, command_line_options):
'\n :param str config_filename:\n :param list[str] command_line_options:\n '
rnn.init(config_filename=config_filename, command_line_options=command_line_options, config_updates={'log': None}, extra_greeting='RETURNN dump-forward starting up.')
rnn.... |
def main(argv):
'\n Main entry.\n '
arg_parser = argparse.ArgumentParser(description='Forward something and dump it.')
arg_parser.add_argument('returnn_config')
arg_parser.add_argument('--epoch', type=int, default=1)
arg_parser.add_argument('--startseq', type=int, default=0, help='start seq ... |
def init(config_filename, command_line_options):
'\n :param str config_filename:\n :param list[str] command_line_options:\n '
rnn.init_better_exchook()
rnn.init_config(config_filename, command_line_options)
global config
config = rnn.config
config.set('log', [])
rnn.init_log()
... |
def main(argv):
'\n Main entry.\n '
arg_parser = argparse.ArgumentParser(description='Dump network as JSON.')
arg_parser.add_argument('returnn_config_file')
arg_parser.add_argument('--epoch', default=1, type=int)
arg_parser.add_argument('--out', default='/dev/stdout')
args = arg_parser.p... |
def main():
'\n Main entry.\n '
arg_parser = ArgumentParser()
arg_parser.add_argument('file')
args = arg_parser.parse_args()
try:
o = pickle.load(open(args.file, 'rb'))
print(better_repr(o))
except BrokenPipeError:
print('BrokenPipeError', file=sys.stderr)
... |
def get_segment_name(tree):
'\n :param tree:\n :return:\n '
def _m(x):
if ('name' in x.attrib):
return x.attrib['name']
if (x.tag == 'segment'):
return '1'
assert False, ('unknown name: %r, %r' % (x, vars(x)))
return '/'.join(map(_m, tree))
|
def iter_bliss_orth(filename):
'\n :param str filename:\n :return:\n '
corpus_file = open(filename, 'rb')
if filename.endswith('.gz'):
corpus_file = gzip.GzipFile(fileobj=corpus_file)
def getelements(tag):
'Yield *tag* elements from *filename_or_file* xml incrementally.'
... |
def iter_dataset_targets(dataset):
'\n :type dataset: Dataset.Dataset\n '
dataset.init_seq_order(epoch=1)
seq_idx = 0
while dataset.is_less_than_num_seqs(seq_idx):
dataset.load_seqs(seq_idx, (seq_idx + 1))
segment_name = dataset.get_tag(seq_idx)
targets = dataset.get_targ... |
class OrthHandler():
'\n Orthography handler.\n '
allo_add_all = False
def __init__(self, lexicon, si_label=None, allo_num_states=3, allo_context_len=1, allow_ci_in_words=True):
'\n :param Lexicon lexicon:\n :param int si_label:\n :param int allo_num_states:\n :p... |
def main():
'\n Main entry.\n '
arg_parser = ArgumentParser()
arg_parser.add_argument('--action')
arg_parser.add_argument('--print_seq', action='store_true')
arg_parser.add_argument('--print_allos', action='store_true')
arg_parser.add_argument('--print_targets', action='store_true')
... |
def main():
'\n Main entry point.\n '
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('--config', help='RETURNN config')
arg_parser.add_argument('--learning-rate-file', help='The learning rate file contains scores / errors per epoch.')
arg_parser.add_argument('--key', help="ke... |
def hdf_dataset_init(file_name):
'\n :param str file_name: filename of hdf dataset file in the filesystem\n :rtype: hdf_dataset_mod.HDFDatasetWriter\n '
return hdf_dataset_mod.HDFDatasetWriter(filename=file_name)
|
def hdf_dump_from_dataset(dataset, hdf_dataset, parser_args):
'\n :param Dataset dataset: could be any dataset implemented as child of Dataset\n :param hdf_dataset_mod.HDFDatasetWriter hdf_dataset:\n :param parser_args: argparse object from main()\n '
hdf_dataset.dump_from_dataset(dataset=dataset,... |
def hdf_close(hdf_dataset):
'\n :param HDFDataset.HDFDatasetWriter hdf_dataset: to close\n '
hdf_dataset.close()
|
def init(config_filename, cmd_line_opts, dataset_config_str):
'\n :param str config_filename: global config for CRNN\n :param list[str] cmd_line_opts: options for init_config method\n :param str dataset_config_str: dataset via init_dataset_via_str()\n '
rnn.init_better_exchook()
rnn.init_threa... |
def _is_crnn_config(filename):
'\n :param str filename:\n :rtype: bool\n '
if filename.endswith('.gz'):
return False
if filename.endswith('.config'):
return True
try:
config = Config()
config.load_file(filename)
return True
except Exception:
... |
def main(argv):
'\n Main entry.\n '
parser = argparse.ArgumentParser(description='Dump dataset or subset of dataset into external HDF dataset')
parser.add_argument('config_file_or_dataset', type=str, help='Config file for RETURNN, or directly the dataset init string')
parser.add_argument('hdf_fi... |
def checkpoint_exists(path):
'\n :param str path:\n :rtype: bool\n '
return (tf_compat.v1.gfile.Exists(path) or tf_compat.v1.gfile.Exists((path + '.meta')) or tf_compat.v1.gfile.Exists((path + '.index')))
|
def main(_):
'\n Main entry.\n '
_logger = logging.getLogger('tensorflow')
_logger.setLevel('INFO')
tf_compat.v1.logging.info(('%s startup. TF version: %s' % (__file__, tf.__version__)))
if FLAGS.checkpoints:
checkpoints = [c.strip() for c in FLAGS.checkpoints.split(',')]
che... |
def print_tensor(v):
'\n :param numpy.ndarray v:\n '
print(v)
mean = numpy.mean(v)
print('mean:', mean)
print('stddev:', numpy.sqrt(numpy.mean(numpy.square((v - mean)))))
print('rms:', numpy.sqrt(numpy.mean(numpy.square(v))))
print('min:', numpy.min(v))
print('max:', numpy.max(v)... |
def print_tensors_in_checkpoint_file(file_name, tensor_name, all_tensors):
'Prints tensors in a checkpoint file.\n\n If no `tensor_name` is provided, prints the tensor names and shapes\n in the checkpoint file.\n\n If `tensor_name` is provided, prints the content of the tensor.\n\n Args:\n file_n... |
def parse_numpy_printoption(kv_str):
"Sets a single numpy printoption from a string of the form 'x=y'.\n\n See documentation on numpy.set_printoptions() for details about what values\n x and y can take. x can be any option listed there other than 'formatter'.\n\n Args:\n kv_str: A string of the form... |
def main(unused_argv):
'\n Main entry:\n '
if (not FLAGS.file_name):
print('Usage: inspect_checkpoint --file_name=checkpoint_file_name [--tensor_name=tensor_to_print]')
sys.exit(1)
else:
print_tensors_in_checkpoint_file(FLAGS.file_name, FLAGS.tensor_name, FLAGS.all_tensors)
|
def main():
'\n Main entry.\n '
argparser = ArgumentParser()
argparser.add_argument('file', help='e.g. events.out.tfevents...')
argparser.add_argument('--tag', default='objective/loss', help="default is 'objective/loss'")
args = argparser.parse_args()
print(('file: %s' % args.file))
... |
def main():
'main entry'
print(f'RETURNN {os.path.basename(__file__)} -- average PyTorch model checkpoints')
print('PyTorch version:', torch.__version__)
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('--checkpoints', nargs='+', required=True, help='comma-separated (or multiple pro... |
def merge_checkpoints(in_ckpts: Sequence[str], out_ckpt: str, extra_state: Optional[Dict[(str, Any)]]=None):
'\n Merge checkpoints\n '
out_model_state: Dict[(str, torch.Tensor)] = {}
out_model_state_num: Dict[(str, int)] = defaultdict(int)
out_state: Dict[(str, Any)] = {'model': out_model_state,... |
def init(config_filename: str, checkpoint: str, log_verbosity: int, device: str):
'\n :param config_filename: Filename to config file.\n :param checkpoint: Filename to the trained model.\n :param log_verbosity: 5 for all seqs (default: 4)\n :param device:\n '
assert os.path.exists(checkpoint), ... |
class ForwardModulePT(torch.nn.Module):
"\n Wrapper of a PyTorch module that's meant to call forward_step from the config when called.\n "
def __init__(self, pt_module: torch.nn.Module, forward_step: Callable, extern_data: TensorDict):
'\n :param pt_module: RF module as obtained from the... |
class ForwardModuleRF(_RFModuleAsPTModule):
"\n Wrapper of a RETURNN frontend module that's meant to call forward_step from the config when called.\n "
def __init__(self, rf_module: rf.Module, forward_step: Callable, extern_data: TensorDict):
'\n :param rf_module: RF module as obtained f... |
def _check_matching_outputs():
rf.get_run_ctx().check_outputs_complete()
model_outputs_raw_keys = set(_get_model_outputs_raw_keys())
outputs_raw = rf.get_run_ctx().outputs.as_raw_tensor_dict(include_scalar_dyn_sizes=False)
outputs_raw_keys = set(outputs_raw.keys())
assert (model_outputs_raw_keys =... |
def _get_model_outputs_raw_keys():
model_outputs = rf.get_run_ctx().expected_outputs
model_outputs_raw_keys = []
for (k, v) in model_outputs.data.items():
model_outputs_raw_keys.append(k)
for (i, dim) in enumerate(v.dims):
if (dim.dyn_size_ext and dim.dyn_size_ext.dims):
... |
def main():
'\n Main entry point\n '
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('config', type=str, help='Filename to config file. Must have `get_model()` and `forward_step()`. Can optionally have `export()`.')
... |
def main():
'main'
numpy.set_printoptions(precision=4, linewidth=80)
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('checkpoint')
arg_parser.add_argument('--key', type=str, default='', help='Name of the tensor or object to inspect. If not given, list them all (but without values, u... |
def print_object(obj: Any, *, print_all_tensors: bool=False, stats_only: bool=False, prefix: str='', ctx: Optional[PrintCtx]=None, ctx_name: Optional[str]=None):
'print object'
if isinstance(obj, (dict, list, tuple)):
for (k, v) in (obj.items() if isinstance(obj, dict) else enumerate(obj)):
... |
def _print_key_value(k: Any, v: Union[(numpy.ndarray, torch.Tensor)], *, print_all_tensors: bool=False, stats_only: bool=False, prefix: str='', ctx: PrintCtx, ctx_name: str):
if isinstance(v, numpy.ndarray):
v = torch.tensor(v)
if isinstance(v, torch.Tensor):
if ((v.numel() <= 1) and (v.device... |
def print_tensor(v: Union[(numpy.ndarray, torch.Tensor)], *, prefix: str='', with_type_and_shape: bool=True, stats_only: bool=False, ctx: Optional[PrintCtx]=None, ctx_name: Optional[str]=None):
'print tensor'
if isinstance(v, numpy.ndarray):
v = torch.tensor(v)
assert isinstance(v, torch.Tensor)
... |
def _format_shape(shape: Tuple[(int, ...)]) -> str:
return ('[%s]' % ','.join(map(str, shape)))
|
def _r(num: Union[(torch.Tensor, float)]) -> str:
return numpy.array2string((num.detach().cpu().numpy() if isinstance(num, torch.Tensor) else num))
|
class PrintCtx():
'print ctx, maybe collect interesting global info'
def __init__(self, *, exclude: List[str]):
self.interesting: Dict[(str, Tuple[(float, str, torch.Tensor)])] = {}
self.exclude = exclude
def visit_tensor(self, *, name: str, tensor: torch.Tensor, max_abs: float):
... |
def parse_numpy_printoption(kv_str):
"Sets a single numpy printoption from a string of the form 'x=y'.\n\n See documentation on numpy.set_printoptions() for details about what values\n x and y can take. x can be any option listed there other than 'formatter'.\n\n Args:\n kv_str: A string of the form... |
def _to_bool(s: str) -> bool:
'\n :param s: str to be converted to bool, e.g. "1", "0", "true", "false"\n :return: boolean value, or fallback\n '
s = s.lower()
if (s in ['1', 'true', 'yes', 'y']):
return True
if (s in ['0', 'false', 'no', 'n']):
return False
raise ValueErr... |
def main():
'main'
print(f'{os.path.basename(__file__)}: {__doc__.strip()}')
numpy.set_printoptions(precision=4, linewidth=80)
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('returnn_config')
arg_parser.add_argument('--cwd')
arg_parser.add_argument('--key', type=str, defaul... |
def syn_shuffle(lst0, lst1, lst2, lst3):
lst = list(zip(lst0, lst1, lst2, lst3))
random.shuffle(lst)
(lst0, lst1, lst2, lst3) = zip(*lst)
return (lst0, lst1, lst2, lst3)
|
class MVTecDataset(Dataset):
def __init__(self, root, transform, gt_transform, phase, category, split_ratio=0.8):
self.phase = phase
if (self.phase in ('train', 'eval')):
self.img_path = os.path.join(root, category, 'train')
else:
self.img_path = os.path.join(root,... |
class MVTecLOCODataset(Dataset):
def __init__(self, root, transform, gt_transform, phase, category, split_ratio=None):
(self.phase == phase)
if (phase == 'train'):
self.img_path = os.path.join(root, category, 'train')
if (phase == 'eval'):
self.img_path = os.path.j... |
class VisaDataset(Dataset):
def __init__(self, root, transform, gt_transform, phase, category=None, split_ratio=0.8):
self.phase = phase
self.root = root
self.category = category
self.transform = transform
self.gt_transform = gt_transform
self.split_ratio = split_r... |
class ImageNetDataset(Dataset):
def __init__(self, imagenet_dir, transform=None):
super().__init__()
self.imagenet_dir = imagenet_dir
self.transform = transform
self.dataset = ImageFolder(self.imagenet_dir, transform=self.transform)
def __len__(self):
return 1000
... |
def load_infinite(loader):
iterator = iter(loader)
while True:
try:
(yield next(iterator))
except StopIteration:
iterator = iter(loader)
|
def get_AD_dataset(type, root, transform, gt_transform=None, phase='train', category=None, split_ratio=1):
if (type == 'VisA'):
return VisaDataset(root, transform, gt_transform, phase, category, split_ratio=split_ratio)
elif (type == 'MVTec'):
return MVTecDataset(root, transform, gt_transform,... |
def cp(src_dir, dst_dir, filename, optional=False):
src_fn = ((src_dir + '/') + filename)
dst_fn = ((dst_dir + '/') + filename)
if (not os.path.exists(src_fn)):
print(('%r does not exist' % src_fn))
assert optional
return
try:
os.makedirs(os.path.dirname(dst_fn))
ex... |
def main():
for (corpus_src, corpus_dst, experiments) in [(swb_src_base_dir, swb_dst_base_dir, swb_experiments)]:
for fn in base_files:
cp(src_dir=corpus_src, dst_dir=corpus_dst, filename=fn)
for setup_name in experiments:
cp(src_dir=corpus_src, dst_dir=corpus_dst, filename... |
def cf(filename):
'Cache manager'
if (filename in _cf_cache):
return _cf_cache[filename]
cached_fn = check_output(['cf', filename]).strip().decode('utf8')
assert os.path.exists(cached_fn)
_cf_cache[filename] = cached_fn
return cached_fn
|
def get_sprint_dataset(data):
assert (data in ['train', 'cv'])
epochSplit = {'train': EpochSplit, 'cv': 1}
files = {}
files['config'] = 'config/training.config'
files['corpus'] = commonfiles['corpus']
files['segments'] = ('dependencies/seg_%s' % {'train': 'train', 'cv': 'cv_head3000'}[data])
... |
def parse_tdp_config(s):
s = s.replace(' ', '').replace('\t', '')
return [('--*.tdp.%s' % l.strip()) for l in s.splitlines() if l.strip()]
|
def get_sprint_error_signal_proc_args():
files = commonfiles.copy()
for (k, v) in sorted(files.items()):
assert os.path.exists(v), ('%s %r does not exist' % (k, v))
return (['--config=config/ctc.train.config', '--action=python-control', '--python-control-loop-type=python-control-loop', '--*.python... |
def check_valid_prior(filename):
from Util import load_txt_vector
v = load_txt_vector(filename)
v = numpy.array(v)
assert (v.ndim == 1)
assert all((v < 0.0)), 'log space assumed'
v = numpy.exp(v)
tot = numpy.sum(v)
assert numpy.isclose(tot, 1.0, atol=0.0001)
|
class Globals():
engine = None
config = None
dataset = None
setup_name = None
setup_dir = None
epoch = None
@classmethod
def get_output_prefix(cls):
return ('fullsum-scores/out.%s.ep%03i.' % (cls.setup_name, cls.epoch))
@classmethod
def get_softmax_prior_filename(cls)... |
def get_softmax_prior():
fn = Globals.get_softmax_prior_filename()
if os.path.exists(fn):
print('Existing softmax prior:', fn)
return fn
print('Calculate softmax prior and save to:', fn)
Globals.config.set('output_file', fn)
Globals.engine.compute_priors(dataset=Globals.dataset, co... |
def calc_fullsum_scores(meta):
from returnn.Util import better_repr
fn = Globals.get_fullsum_scores_filename(**meta)
if os.path.exists(fn):
print('Existing fullsum scores filename:', fn)
print(('content:\n%s\n' % open(fn).read()))
return fn
assert ('output_fullsum' in Globals.e... |
def main():
argparser = ArgumentParser(description=__doc__, formatter_class=RawTextHelpFormatter)
argparser.add_argument('--model', required=True, help='or config, or setup')
argparser.add_argument('--epoch', required=True, type=int)
argparser.add_argument('--prior', help='none, fixed, softmax (defaul... |
class Settings():
recog_metric_name = 'WER'
recog_score_lower_is_better = True
|
def run(args, **kwargs):
import subprocess
kwargs = kwargs.copy()
print(('$ %s' % ' '.join(args)), {k: (v if (k != 'input') else '...') for (k, v) in kwargs.items()})
try:
subprocess.run(args, **kwargs, check=True)
except KeyboardInterrupt:
print('KeyboardInterrupt')
sys.ex... |
def qsub_name_from_args(args):
return ('qsub_' + '_'.join(args).replace('./', '').replace('/', '').replace(' ', ''))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.