code stringlengths 17 6.64M |
|---|
def add_suffix(string, suffix):
if (not string.endswith(suffix)):
return (string + suffix)
return string
|
def partition_into_tree(l, m):
' Transforms the list l into a nested list where each sub-list has at most length m + 1'
nextPartition = partition = l
while (len(nextPartition) > 1):
partition = nextPartition
nextPartition = []
d = (len(partition) // m)
mod = (len(partition)... |
def reduce_tree(func, tree):
return func([(reduce_tree(func, e) if (type(e) == list) else e) for e in tree])
|
def uopen(path, *args, **kwargs):
path = tk.uncached_path(path)
if path.endswith('.gz'):
return gzip.open(path, *args, **kwargs)
else:
return open(path, *args, **kwargs)
|
def get_val(var):
if isinstance(var, Variable):
return var.get()
return var
|
def chunks(l, n):
'\n :param list[T] l: list which should be split into chunks\n :param int n: number of chunks\n :return: yields n chunks\n :rtype: list[list[T]]\n '
bigger_count = (len(l) % n)
start = 0
block_size = (len(l) // n)
for i in range(n):
end = ((start + block_size) + (1 i... |
class AutoCleanup(Job):
def __init__(self, job_list, trigger):
'\n :param list[Job] job_list:\n :param tk.Path trigger:\n '
self.job_list = job_list
self.trigger = trigger
self.out = self.output_path('cleanup_complete')
assert (trigger.creator not in job_list)
... |
def engine():
from sisyphus.localengine import LocalEngine
return LocalEngine(cpus=4, gpus=1)
|
def number_convert(word):
try:
f = float(word)
return num2words(f)
except:
return word
|
def main():
parser = argparse.ArgumentParser(description='TTS decoder running RETURNN TTS and an MB-MelGAN vocoder')
parser.add_argument('--returnn_config', type=str, help='RETURNN config file (.config)')
parser.add_argument('--vocab_file', type=str, help='RETURNN vocab file (.pkl)')
parser.add_argume... |
class PWGTrain(Job):
'\n\n '
def __init__(self, pwg_config, pwg_train_dataset, pwg_dev_dataset, pwg_exe=PWG_EXE, pwg_src_root=PWG_ROOT):
'\n\n :param dict pwg_config:\n :param Path pwg_train_dataset:\n :param Path pwg_dev_dataset:\n :param Path|str pwg_exe:\n :pa... |
class PWGBuildDataset(Job):
'\n This Job converts a dataset in zip_format and an HDF output file generated into the appriopriate format for\n the PWG training. The frame hop needs to be specified to adjust for the possible length mismatch between\n features and audio.\n '
def __init__(self, zip_d... |
def generic_open(filename, mode='r'):
'\n Wrapper around :func:`open`.\n Automatically wraps :func:`gzip.open` if filename ends with ``".gz"``.\n\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
... |
def sh(*args):
print(('$ %s' % ' '.join(args)))
subprocess.check_call(args)
|
@contextlib.contextmanager
def pushd(d):
'\n :param str d: directory\n '
assert os.path.isdir(d)
old_working_dir = os.getcwd()
os.chdir(d)
(yield)
os.chdir(old_working_dir)
|
def create_librispeech_txt(dataset_dir):
'\n Create separate txt files to be used with :class:`returnn.OggZipDataset`.\n Example:\n https://github.com/rwth-i6/returnn-experiments/blob/master/2019-asr-e2e-trafo-vs-lstm/tedlium2/full-setup/03_convert_to_ogg.py\n\n :param str dataset_dir:\n '
output_dir =... |
def extract_raw_strings_py(part):
'\n :param str part:\n :rtype: str\n '
dataset_dir = ('%s/data/dataset-ogg' % my_dir)
dataset_path_prefix = ('%s/%s' % (dataset_dir, part))
py_txt_output_path = ('%s/data/dataset/%s.py.txt.gz' % (my_dir, part))
if os.path.exists(py_txt_output_path):
pri... |
def main():
os.makedirs(('%s/data/dataset' % my_dir), exist_ok=True)
create_librispeech_txt(dataset_dir=('%s/data/dataset-ogg' % my_dir))
trans_file = open(('%s/data/dataset/train-trans-all.txt' % my_dir), 'w')
for part in Parts:
py_txt_output_path = extract_raw_strings_py(part)
if par... |
def get_filename(config):
for base_dir in base_dirs:
fn = ('%s/config-train/%s.config' % (base_dir, config))
print(fn)
if os.path.exists(fn):
return fn
raise Exception(('not found: %s' % config))
|
def main():
os.chdir(os.path.dirname(os.path.abspath(__file__)))
for base_dir in base_dirs:
assert os.path.exists(base_dir)
for config in configs:
fn = get_filename(config)
local_fn = ('%s.config' % config)
if (not os.path.exists(local_fn)):
shutil.copy(fn, loca... |
def save_corpus_segments_to_file(output_filename, input_dict):
'\n :param str output_filename:\n :param dict[str,str] input_dict:\n '
with open(output_filename, 'w') as file:
file.write('{\n')
for (key, value) in input_dict.items():
value = value.lstrip()
file.write(... |
class PhoneMapper():
def __init__(self, lexicon_filename, phone_unicode_map_filename=None):
'\n :param str lexicon_filename:\n :param str phone_unicode_map_filename:\n '
self._lexicon_filename = lexicon_filename
self._phone_unicode_map = phone_unicode_map_filename
self._l... |
def convert(string_num):
if (isinstance(string_num, str) and string_num.startswith('0')):
return ('zero ' + convert(string_num[1:]))
num = int(string_num)
units = ('', 'one ', 'two ', 'three ', 'four ', 'five ', 'six ', 'seven ', 'eight ', 'nine ', 'ten ', 'eleven ', 'twelve ', 'thirteen ', 'fourt... |
def hasNumber(inputString):
return any((char.isdigit() for char in inputString))
|
def separate(iString):
prev_char = iString[0]
tmp = []
new = iString[0]
for (x, i) in enumerate(iString[1:]):
if (i.isalpha() and prev_char.isalpha()):
new += i
elif (i.isnumeric() and prev_char.isnumeric()):
new += i
else:
tmp.append(new)
... |
def to_unicode_list(input_l):
res = []
for item in input_l:
res.append(to_unicode(item))
return res
|
def to_unicode(input):
text = input.split()
result = ''
for k in text:
result += phone_to_unicode[k]
return result
|
def main():
arg_parser = ArgumentParser()
arg_parser.add_argument('--bpe_vocab', required=True)
arg_parser.add_argument('--lexicon', required=True)
arg_parser.add_argument('--phones_bpe', required=True)
arg_parser.add_argument('--bpe', action='store_true')
arg_parser.add_argument('--char', act... |
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 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 main():
argparser = ArgumentParser()
argparser.add_argument('file', help="by Returnn search, in 'py' format")
argparser.add_argument('--out', required=True, help='output filename')
args = argparser.parse_args()
d = eval(open(args.file, 'r').read())
assert isinstance(d, dict)
assert (no... |
def main():
argparser = ArgumentParser()
argparser.add_argument('file', help="by Returnn search, in 'py' format")
argparser.add_argument('--out', required=True, help='output filename')
args = argparser.parse_args()
d = eval(open(args.file, 'r').read())
assert isinstance(d, dict)
assert (no... |
def parse_vocab(filename):
'\n :param str filename:\n :rtype: dict[str,str]\n :return: phone->unicode\n '
raw = open(filename, 'r').read()
return eval(raw)
|
def main():
args_parser = ArgumentParser()
args_parser.add_argument('--lexicon', required=True)
args_parser.add_argument('--input', required=True)
args_parser.add_argument('--disamb_map', required=True)
args_parser.add_argument('--disamb', action='store_true')
args_parser.add_argument('--outpu... |
def get_filename(config):
for base_dir in base_dirs:
fn = ('%s/config-train/%s.config' % (base_dir, config))
print(fn)
if os.path.exists(fn):
return fn
raise Exception(('not found: %s' % config))
|
def main():
os.chdir(os.path.dirname(os.path.abspath(__file__)))
for base_dir in base_dirs:
assert os.path.exists(base_dir)
for config in configs:
fn = get_filename(config)
local_fn = ('%s.config' % config)
if (not os.path.exists(local_fn)):
shutil.copy(fn, loca... |
class ConcatSwitchboard(Job):
'\n Based on a STM file, create concatenated dataset.\n '
@classmethod
def create_all_for_num(cls, num, register_output_prefix=None, experiments=None):
'\n Via ``ScliteHubScoreJob.RefsStmFiles``.\n\n :param int num:\n :param str|None register_output_prefix... |
def score_hyps(experiment, dataset, hyps):
'\n :param returnn.experiments.ExperimentFromConfig|None experiment: (unused)\n :param str dataset: from experiments.dataset_inference_keys\n :param Path hyps:\n :rtype: list[Path]\n '
return scoring.ScliteHubScoreJob.create_by_corpus_name(name=dataset, hyps=hyp... |
class CalculateWordErrorRateJob(Job):
def __init__(self, refs, hyps):
'\n :param Path refs: Python txt format, seq->txt, whole words\n :param Path hyps: Python txt format, seq->txt, whole words\n '
self.refs = refs
self.hyps = hyps
self.output_wer = self.output_path('wer.... |
class ScliteJob(Job):
'\n Run sclite.\n '
def __init__(self, name, refs, hyps):
'\n :param str name: e.g. dataset name (test-clean or so), just for the output reporting, not used otherwise\n :param Path refs: Python txt format, seq->txt, whole words\n :param Path hyps: Python txt format, s... |
class ScliteHubScoreJob(Job):
"\n Wraps the SCTK hubscr.pl script, which is used to calculate the WER for Switchboard, Hub 5'00, Hub 5'01, rts03.\n "
CorpusNameMap = {'dev': 'hub5e_00'}
OrigCorpusNames = ['hub5e_00', 'hub5e_01', 'rt03s']
ResultsSubsets = {'hub5e_00': ['Callhome', 'Switchboard', 'Ove... |
def generic_open(filename, mode='r'):
'\n Wrapper around :func:`open`.\n Automatically wraps :func:`gzip.open` if filename ends with ``".gz"``.\n\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
... |
def hash_limited_len_name(name, limit=200):
'\n :param str name:\n :param int limit:\n :return: name, maybe truncated (by hash) such that its len (in bytes) is <=200\n :rtype: str\n '
name_b = name.encode('utf8')
if (len(name_b) < limit):
return name
assert (len(name_b) == len(name))
... |
def get_config_filename(config):
for base_dir in base_dirs:
fn = ('%s/config-train/%s.config' % (base_dir, config))
if os.path.exists(fn):
return fn
raise Exception(('not found: %s' % config))
|
def main():
os.chdir(os.path.dirname(os.path.abspath(__file__)))
for base_dir in base_dirs:
assert os.path.exists(base_dir)
for config in configs:
fn = get_config_filename(config)
local_fn = ('%s.config' % config)
if (not os.path.exists(local_fn)):
shutil.copy(f... |
def logsumexp(*args):
'\n Stable log sum exp.\n '
if all(((a == NEG_INF) for a in args)):
return NEG_INF
a_max = max(args)
lsp = np.log(sum((np.exp((a - a_max)) for a in args)))
return (a_max + lsp)
|
def log_softmax(acts, axis):
'\n Log softmax over the last axis of the 3D array.\n '
acts = (acts - np.max(acts, axis=axis, keepdims=True))
probs = np.sum(np.exp(acts), axis=axis, keepdims=True)
log_probs = (acts - np.log(probs))
return log_probs
|
def forward_pass(log_probs, labels, blank, label_rep=False):
(T, U, _) = log_probs.shape
S = ((T - U) + 2)
alphas = np.zeros((S, U))
for u in range(1, U):
alphas[(0, u)] = (alphas[(0, (u - 1))] + log_probs[((u - 1), (u - 1), labels[(u - 1)])])
for t in range(1, S):
alphas[(t, 0)] =... |
def backward_pass(log_probs, labels, blank):
(T, U, _) = log_probs.shape
S = ((T - U) + 2)
S1 = (S - 1)
U1 = (U - 1)
betas = np.zeros((S, U))
for i in range(1, U):
u = (U1 - i)
betas[(S1, u)] = (betas[(S1, (u + 1))] + log_probs[((T - i), u, labels[u])])
for i in range(1, S)... |
def analytical_gradient(log_probs, alphas, betas, labels, blank):
(T, U, _) = log_probs.shape
S = ((T - U) + 2)
log_like = betas[(0, 0)]
grads = np.full(log_probs.shape, NEG_INF)
for t in range((S - 1)):
for u in range(U):
grads[((t + u), u, blank)] = (((alphas[(t, u)] + betas[... |
def numerical_gradient(log_probs, labels, neg_loglike, blank):
epsilon = 1e-05
(T, U, V) = log_probs.shape
grads = np.zeros_like(log_probs)
for t in range(T):
for u in range(U):
for v in range(V):
log_probs[(t, u, v)] += epsilon
(alphas, ll_forward) ... |
def test():
np.random.seed(0)
blank = 0
vocab_size = 4
input_len = 5
output_len = 3
print(('T=%d, U=%d, V=%d' % (input_len, (output_len + 1), vocab_size)))
inputs = np.random.rand(input_len, (output_len + 1), vocab_size)
labels = np.random.randint(1, vocab_size, output_len)
log_pro... |
def main():
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('setup')
arg_parser.add_argument('--align-layer', default='ctc_align')
arg_parser.add_argument('--prior-scale', default=None)
arg_parser.add_argument('--extern-prior')
args = arg_parser.parse_args()
config_filename ... |
def main():
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('setup')
arg_parser.add_argument('--softmax-layer', default='ctc_out')
args = arg_parser.parse_args()
config_filename = ('%s/config-train/%s.config' % (setup_base_dir, args.setup))
setup_dir = ('%s/data-train/%s' % (set... |
class AddOneHotToTime(CopyLayer):
layer_class = 'addonehot'
def __init__(self, position=0, repeat=1, vocab_size=30000, **kwargs):
'\n :param float|str prefix: either some constant or another layer\n :param int repeat: how often to repeat the prefix\n '
super(AddOneHotToTime, self).__... |
def gen_model_1label():
'\n \\sum_{s:y} p(x|s),\n two possible inputs x1 (1,0) and x2 (0,1),\n two possible labels "a" and (blank) "B".\n Define p(x1|s=a) = theta_a, p(x2|s=a) = 1 - theta_a,\n p(x2|s=B) = theta_B, p(x1|s=B) = 1 - theta_B.\n\n For simplicity, fsa ^= a*B*, and the input be x1^{na},x2^{nB}, T ... |
def main():
if (len(sys.argv) >= 2):
globals()[sys.argv[1]]()
return
print(('Usage: %s <func>' % __file__))
sys.exit(1)
|
class Arc():
def __init__(self, source_state: int, target_state: int, label: str):
self.source_state = source_state
self.target_state = target_state
self.label = label
def short_str(self, target_is_final_mark: bool=False):
return ('%i -%s-> %i%s' % (self.source_state, self.la... |
class Fsa():
'\n Finite state automaton.\n '
def __init__(self):
self.states = {0}
self.start_state = 0
self.final_states = set()
self.arcs = set()
self.arcs_by_source_state = {}
def add_arc(self, source_state: int, target_state: int, label: str):
self.s... |
def iterate_all_paths(fsa: Fsa, num_frames: int, state: typing.Union[(None, int)]=None) -> typing.Generator[(typing.List[Arc], None, None)]:
if (state is None):
state = fsa.start_state
if (num_frames == 0):
if (state in fsa.final_states):
(yield [])
return
assert (num_f... |
def count_all_paths_inefficient(fsa: Fsa, num_frames: int) -> int:
return len(list(iterate_all_paths(fsa=fsa, num_frames=num_frames)))
|
def count_all_paths_with_label_in_frame_inefficient(fsa: Fsa, num_frames: int, frame_idx: int, label: str) -> int:
return len([path for path in iterate_all_paths(fsa=fsa, num_frames=num_frames) if (path[frame_idx].label == label)])
|
@sympy.cacheit
def count_all_paths(fsa: Fsa, state: typing.Union[(None, int)]=None) -> (sympy.Symbol, sympy.Expr):
'\n :return: (num_frames, count).\n num_frames is a symbolic var,\n count is the count of all unique paths from the given state (or start state) to any final state.\n '
if (state is None)... |
@sympy.cacheit
def count_all_paths_with_label_in_frame(fsa: Fsa, label: str) -> (sympy.Symbol, sympy.Symbol, sympy.Expr):
'\n :return: (num_frames, frame_idx, count)\n '
num_frames = sympy.Symbol('num_frames', integer=True, nonnegative=True)
frame_idx = sympy.Symbol('frame_idx', integer=True, nonnegativ... |
def count_all_paths_with_label_avg(fsa: Fsa, label: str, num_frames: typing.Optional[int]=None):
(num_frames_, frame_idx, count) = count_all_paths_with_label_in_frame(fsa=fsa, label=label)
count_sum = sympy.Sum(count, (frame_idx, 0, (num_frames_ - 1)))
for _ in range(4):
count_sum = count_sum.simp... |
def count_all_paths_with_label_seq(fsa: Fsa, label_seq_template: str):
'\n :param Fsa fsa:\n :param str label_seq_template: example "baab". this will get upsampled for num_frames, e.g. "bbaaaabb"\n '
n = sympy.Symbol('n', integer=True, nonnegative=True)
num_frames = (len(label_seq_template) * n)
fr... |
def count_all_paths_with_label_seq_partly_dominated(fsa: Fsa, label_seq_template: str, dom_label: str, n: typing.Union[(int, sympy.Symbol)], factor: typing.Union[(int, float, sympy.Symbol)], fixed_factor_power: typing.Optional[typing.Union[(sympy.Symbol, sympy.Expr)]]=None) -> typing.Dict[(typing.Tuple[(str, str)], t... |
def count_all_paths_with_label_seq_partly_dominated_inefficient(fsa: Fsa, label_seq_template: str, dom_label: str, n: int, prob_dom: float, normalized: bool=True, verbosity: int=0) -> typing.Dict[(typing.Tuple[(str, str)], typing.Dict[(str, float)])]:
'\n Same as :func:`count_all_paths_with_label_seq_partly_domi... |
def full_sum(fsa: Fsa, label_seq_template: str):
n = sympy.Symbol('n', integer=True, nonnegative=True)
states = sorted(fsa.states)
input_labels = sorted(set(label_seq_template))
labels = fsa.get_labels()
probs_by_label_by_input = {input_label: {} for input_label in input_labels}
prob_vars = []... |
def get_std_fsa_1label():
fsa = Fsa()
fsa.add_arc(0, 0, BlankLabel)
fsa.add_arc(0, 1, Label1)
fsa.add_arc(1, 1, Label1)
fsa.add_arc(1, 2, BlankLabel)
fsa.add_arc(2, 2, BlankLabel)
fsa.add_final_state(1)
fsa.add_final_state(2)
return fsa
|
def get_std_fsa_1label_2times():
fsa = Fsa()
fsa.add_arc(0, 0, BlankLabel)
fsa.add_arc(0, 1, Label1)
fsa.add_arc(1, 1, Label1)
fsa.add_arc(1, 2, BlankLabel)
fsa.add_arc(2, 2, BlankLabel)
fsa.add_arc(2, 3, Label1)
fsa.add_arc(3, 3, Label1)
fsa.add_arc(3, 4, BlankLabel)
fsa.add_a... |
def get_std_fsa_2label():
fsa = Fsa()
fsa.add_arc(0, 0, BlankLabel)
fsa.add_arc(0, 1, Label1)
fsa.add_arc(1, 1, Label1)
fsa.add_arc(1, 2, BlankLabel)
fsa.add_arc(2, 2, BlankLabel)
fsa.add_arc(1, 3, Label2)
fsa.add_arc(2, 3, Label2)
fsa.add_arc(3, 3, Label2)
fsa.add_arc(3, 4, Bl... |
def get_std_fsa_3label_blank():
fsa = Fsa()
fsa.add_arc(0, 0, BlankLabel)
fsa.add_arc(0, 1, Label1)
fsa.add_arc(1, 1, Label1)
fsa.add_arc(1, 2, BlankLabel)
fsa.add_arc(2, 2, BlankLabel)
fsa.add_arc(1, 3, Label2)
fsa.add_arc(2, 3, Label2)
fsa.add_arc(3, 3, Label2)
fsa.add_arc(3,... |
def get_std_fsa_3label_sil():
fsa = Fsa()
fsa.add_arc(0, 0, BlankLabel)
fsa.add_arc(0, 1, Label1)
fsa.add_arc(1, 1, Label1)
fsa.add_arc(1, 2, Label2)
fsa.add_arc(2, 2, Label2)
fsa.add_arc(2, 3, Label3)
fsa.add_arc(3, 3, Label3)
fsa.add_arc(3, 4, BlankLabel)
fsa.add_arc(4, 4, Bl... |
def get_std_fsa_4label_2words_blank():
fsa = Fsa()
fsa.add_arc(0, 0, BlankLabel)
fsa.add_arc(0, 1, Label1)
fsa.add_arc(1, 1, Label1)
fsa.add_arc(1, 2, BlankLabel)
fsa.add_arc(2, 2, BlankLabel)
fsa.add_arc(1, 3, Label2)
fsa.add_arc(2, 3, Label2)
fsa.add_arc(3, 3, Label2)
fsa.add... |
def get_std_fsa_4label_2words_sil():
fsa = Fsa()
fsa.add_arc(0, 0, BlankLabel)
fsa.add_arc(0, 1, Label1)
fsa.add_arc(1, 1, Label1)
fsa.add_arc(1, 2, Label2)
fsa.add_arc(2, 2, Label2)
fsa.add_arc(2, 3, Label3)
fsa.add_arc(3, 3, Label3)
fsa.add_arc(3, 4, BlankLabel)
fsa.add_arc(4... |
def test_count_all_paths(fsa: Fsa, num_frames: int):
c_ = count_all_paths_inefficient(fsa=fsa, num_frames=num_frames)
print(('count all paths for T=%i explicit:' % num_frames), c_)
(n, c) = count_all_paths(fsa=fsa)
print('count all paths symbolic:', n, '->', c)
c__ = c.subs(n, num_frames).doit()
... |
def test_count_all_paths_with_label_in_frame(fsa: Fsa, num_frames: int, frame_idx: int, label: str):
c_ = count_all_paths_with_label_in_frame_inefficient(fsa=fsa, num_frames=num_frames, frame_idx=frame_idx, label=label)
print(('count all paths with t=%i, T=%i, l=%s explicit:' % (frame_idx, num_frames, label))... |
def count_paths_with_label(fsa: Fsa, num_frames: int, label: str):
(_n, _t, count_blank_sym) = count_all_paths_with_label_in_frame(fsa=fsa, label=label)
n_t = sympy.Symbol('T', integer=True)
t1 = sympy.Symbol('t', integer=True)
count_blank_sym = count_blank_sym.subs(_n, n_t).subs(_t, (t1 - 1)).simplif... |
def match(fsa: Fsa, input_seq: str) -> typing.Optional[typing.List[Arc]]:
'\n Match the input_seq to the FSA.\n Assumes that the FSA is deterministic by label.\n '
path = []
state = fsa.start_state
for label in input_seq:
next_state = None
for arc in fsa.arcs_by_source_state[state]:... |
def bias_model(fsa: Fsa, num_frames: int):
print(('Bias model with T=%i:' % num_frames))
labels = fsa.get_labels()
label_probs = {}
for label in labels[:(- 1)]:
label_probs[label] = sympy.Symbol(('prob_%s' % label), real=True, nonnegative=True)
label_probs[labels[(- 1)]] = (1 - sum([label_... |
def bias_model_1label(num_frames: int):
print('Bias model with fixed FSA.')
labels = ['B', 'a']
label_prob0 = sympy.Symbol('prob_B', real=True)
i = sympy.Symbol('i', integer=True, positive=True)
n = sympy.Symbol('T', integer=True, positive=True)
prob_sum = (sympy.Sum(((i * sympy.Pow(label_prob... |
def test_count_all_paths_with_label_seq_partly_dominated(recalc=False, check=False, check_with_factor=False):
fsa = get_std_fsa_1label()
n_ = 4
n = sympy.Symbol('n', integer=True, positive=True)
factor = sympy.Symbol('fact', real=True, positive=True)
res = count_all_paths_with_label_seq_partly_dom... |
def gen_model_1label():
'\n \\sum_{s:y} p(x|s),\n two possible inputs x1 (1,0) and x2 (0,1),\n two possible labels "a" and (blank) "B".\n Define p(x1|s=a) = theta_a, p(x2|s=a) = 1 - theta_a,\n p(x2|s=B) = theta_B, p(x1|s=B) = 1 - theta_B.\n\n For simplicity, fsa ^= a*B*, and the input be x1^{na},x2^{nB}, T ... |
def gen_model_1label_bab():
n = sympy.Symbol('n', integer=True, positive=True)
t_end = (n * 4)
theta_a = sympy.Symbol('theta_a', real=True, nonnegative=True)
theta_b = sympy.Symbol('theta_b', real=True, nonnegative=True)
t1 = sympy.Symbol('t1', integer=True, nonnegative=True)
t2 = sympy.Symbol... |
def gen_model_fsa_template_via_matrix(fsa: Fsa, label_seq_template: str):
n = sympy.Symbol('n', integer=True, nonnegative=True)
num_frames = (len(label_seq_template) * n)
states = sorted(fsa.states)
input_labels = sorted(set(label_seq_template))
labels = fsa.get_labels()
probs_by_label_by_inpu... |
def test_tf_grad_log_sm():
import tensorflow as tf
print('TF version:', tf.__version__)
with tf.Session() as session:
x = tf.constant([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]])
y = tf.nn.log_softmax(x)
scores = [0.0, float('-inf'), float('-inf')]
def combine(s_, y_):
... |
def test_ctc():
import tensorflow as tf
print('TF version:', tf.__version__)
fsa = get_std_fsa_3label_blank()
num_batch = 1
num_frames = 100
num_labels = 4
with tf.Session() as session:
labels = tf.SparseTensor(indices=[[0, 0], [0, 1], [0, 2]], values=[0, 1, 2], dense_shape=[num_ba... |
def main():
if (len(sys.argv) >= 2):
globals()[sys.argv[1]]()
return
label_seq_template = Label1StrTemplate
fsa = get_std_fsa_1label()
print('fsa:', fsa)
assert fsa.is_deterministic_by_label()
assert match(fsa=fsa, input_seq=label_seq_template)
num_frames = 16
print(('T... |
def plot_alignment(alignment, labels, filename=None):
'\n :param list[int]|list[list[float]] alignment:\n :param list[str] labels:\n :param str|None filename:\n '
num_labels = len(labels)
num_frames = len(alignment)
ts = range(num_frames)
if isinstance(alignment[0], list):
assert (len(... |
def main():
labels = ['p', 'ih', 'ng', 'sil']
labels_blank = (labels[:(- 1)] + ['blank'])
n_ = 10
align_opt_sil = (((((([4] * 2) * n_) + ([1] * n_)) + (([2] * 3) * n_)) + (([3] * 2) * n_)) + (([4] * 2) * n_))
align_peaky_sil = [(x + 1) for x in [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3... |
def range_from_relationals(and_expr: typing.Union[(sympy.And, sympy.Rel)], gen: sympy.Symbol) -> (typing.Optional[sympy.Basic], typing.Optional[sympy.Basic]):
'\n :return whether there is a solution, optional start range, optional end range\n (including; assume integer; assume simplified)\n '
if isinstan... |
def simplify_and(x: sympy.Basic, gen: typing.Optional[sympy.Symbol]=None, extra_conditions: typing.Optional[sympy.Basic]=True) -> sympy.Basic:
'\n Some rules, because SymPy currently does not automatically simplify them...\n '
assert isinstance(x, sympy.Basic), ('type x: %r' % type(x))
from sympy.solver... |
def sum_over_piecewise(expr: sympy.Piecewise, sum_var: sympy.Symbol, sum_start: typing.Union[(sympy.Basic, int)], sum_end: sympy.Basic, extra_condition: sympy.Basic=True) -> sympy.Expr:
'\n :return: equivalent to Sum(expr, (sum_var, sum_start, sum_end)), but we try to remove the piecewise.\n We assume that th... |
def binomial_expansion(a, b, exp):
'\n Applies the binomial expansion (https://en.wikipedia.org/wiki/Binomial_theorem).\n\n :param sympy.Expr|int a:\n :param sympy.Expr|int b:\n :param sympy.Expr|int exp: assumes to be a nonnegative integer\n :rtype sympy.Expr\n '
i = sympy.Symbol('i', integer=True, non... |
def polynomial_exp(a, b, exp, expand=True, flip=True):
'\n :param sympy.Expr|int a:\n :param sympy.Expr|int b:\n :param sympy.Expr|int exp: assumes to be a nonnegative integer\n :param bool expand:\n :param bool flip:\n :rtype sympy.Expr\n '
if expand:
a = sympy.sympify(a)
b = sympy.sym... |
class NameAxisLayer(_ConcatInputLayer):
'\n Adds a DimensionTag to an axis s.t. it will be unique.\n '
layer_class = 'name_axis'
def __init__(self, axis, description, **kwargs):
super(NameAxisLayer, self).__init__(**kwargs)
from returnn.tf.layers.base import LayerBase
batch_dim ... |
def _query_key_time_default(query_time_axis, key_time_axis):
'\n :param None|str query_time_axis:\n :param None|str key_time_axis:\n :rtype: tuple[str,str]\n '
assert ((query_time_axis is None) == (key_time_axis is None))
if (query_time_axis is None):
query_time_axis = 'stag:extern_data:classe... |
def make_lsh_hash_gen(d, output, key_dim, num_hashes, num_heads, num_rounds, hash_init=("variance_scaling_initializer(mode='fan_in', distribution='uniform', scale=%s)" % 1.0)):
"\n :param dict[str,dict] d: the network dict to write into\n :param str output: prefix of all layers generated. Output is written into... |
def apply_lsh_hash_gen(d, input, hash_gen_input, output, num_hashes, time_axis, hash_mask_value=((2 ** 31) - 1), hash_dropin=0.0):
'\n :param dict[str,dict] d:\n :param str input:\n :param str hash_gen_input:\n :param str output:\n :param int num_hashes:\n :param str time_axis:\n :param int|None hash_mask_... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.