Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,36 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+UniAudio/UniAudio/tools/tokenizer/phone/lexicon.txt filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.1.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.10.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.11.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.12.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.13.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.14.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.15.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.16.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.2.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.3.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.4.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.5.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.6.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.7.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.8.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_UniAudio.9.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.1.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.10.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.11.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.12.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.13.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.14.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.15.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.16.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.2.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.3.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.4.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.5.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.6.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.7.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.8.ark filter=lfs diff=lfs merge=lfs -text
+dump/raw_codec_ssl_tts_librispeech/test_clean/data/wav_codec_ssl_UniAudio.9.ark filter=lfs diff=lfs merge=lfs -text

UniAudio/UniAudio/download.sh

@@ -0,0 +1,8 @@
+mkdir UniAudio/checkpoints
+cd UniAudio/checkpoints
+wget https://huggingface.co/Dongchao/UniAudio/resolve/main/lang_nosp.zip
+unzip lang_nosp.zip
+wget https://huggingface.co/Dongchao/UniAudio/resolve/main/universal_model.zip
+unzip universal_model.zip
+wget https://huggingface.co/Dongchao/UniAudio/resolve/main/hubert_base_ls960.pt
+wget https://huggingface.co/Dongchao/UniAudio/resolve/main/hubert_base_ls960_L9_km500.bin

UniAudio/UniAudio/egs/SE/cmd.sh

@@ -0,0 +1,110 @@
+# ====== About run.pl, queue.pl, slurm.pl, and ssh.pl ======
+# Usage: <cmd>.pl [options] JOB=1:<nj> <log> <command...>
+# e.g.
+#   run.pl --mem 4G JOB=1:10 echo.JOB.log echo JOB
+#
+# Options:
+#   --time <time>: Limit the maximum time to execute.
+#   --mem <mem>: Limit the maximum memory usage.
+#   -–max-jobs-run <njob>: Limit the number parallel jobs. This is ignored for non-array jobs.
+#   --num-threads <ngpu>: Specify the number of CPU core.
+#   --gpu <ngpu>: Specify the number of GPU devices.
+#   --config: Change the configuration file from default.
+#
+# "JOB=1:10" is used for "array jobs" and it can control the number of parallel jobs.
+# The left string of "=", i.e. "JOB", is replaced by <N>(Nth job) in the command and the log file name,
+# e.g. "echo JOB" is changed to "echo 3" for the 3rd job and "echo 8" for 8th job respectively.
+# Note that the number must start with a positive number, so you can't use "JOB=0:10" for example.
+#
+# run.pl, queue.pl, slurm.pl, and ssh.pl have unified interface, not depending on its backend.
+# These options are mapping to specific options for each backend and
+# it is configured by "conf/queue.conf" and "conf/slurm.conf" by default.
+# If jobs failed, your configuration might be wrong for your environment.
+#
+#
+# The official documentation for run.pl, queue.pl, slurm.pl, and ssh.pl:
+#   "Parallelization in Kaldi": http://kaldi-asr.org/doc/queue.html
+# =========================================================~
+
+
+# Select the backend used by run.sh from "local", "stdout", "sge", "slurm", or "ssh"
+cmd_backend='local'
+
+# Local machine, without any Job scheduling system
+if [ "${cmd_backend}" = local ]; then
+
+    # The other usage
+    export train_cmd="run.pl"
+    # Used for "*_train.py": "--gpu" is appended optionally by run.sh
+    export cuda_cmd="run.pl"
+    # Used for "*_recog.py"
+    export decode_cmd="run.pl"
+
+# Local machine logging to stdout and log file, without any Job scheduling system
+elif [ "${cmd_backend}" = stdout ]; then
+
+    # The other usage
+    export train_cmd="stdout.pl"
+    # Used for "*_train.py": "--gpu" is appended optionally by run.sh
+    export cuda_cmd="stdout.pl"
+    # Used for "*_recog.py"
+    export decode_cmd="stdout.pl"
+
+
+# "qsub" (Sun Grid Engine, or derivation of it)
+elif [ "${cmd_backend}" = sge ]; then
+    # The default setting is written in conf/queue.conf.
+    # You must change "-q g.q" for the "queue" for your environment.
+    # To know the "queue" names, type "qhost -q"
+    # Note that to use "--gpu *", you have to setup "complex_value" for the system scheduler.
+
+    export train_cmd="queue.pl"
+    export cuda_cmd="queue.pl"
+    export decode_cmd="queue.pl"
+
+
+# "qsub" (Torque/PBS.)
+elif [ "${cmd_backend}" = pbs ]; then
+    # The default setting is written in conf/pbs.conf.
+
+    export train_cmd="pbs.pl"
+    export cuda_cmd="pbs.pl"
+    export decode_cmd="pbs.pl"
+
+
+# "sbatch" (Slurm)
+elif [ "${cmd_backend}" = slurm ]; then
+    # The default setting is written in conf/slurm.conf.
+    # You must change "-p cpu" and "-p gpu" for the "partition" for your environment.
+    # To know the "partion" names, type "sinfo".
+    # You can use "--gpu * " by default for slurm and it is interpreted as "--gres gpu:*"
+    # The devices are allocated exclusively using "${CUDA_VISIBLE_DEVICES}".
+
+    export train_cmd="slurm.pl"
+    export cuda_cmd="slurm.pl"
+    export decode_cmd="slurm.pl"
+
+elif [ "${cmd_backend}" = ssh ]; then
+    # You have to create ".queue/machines" to specify the host to execute jobs.
+    # e.g. .queue/machines
+    #   host1
+    #   host2
+    #   host3
+    # Assuming you can login them without any password, i.e. You have to set ssh keys.
+
+    export train_cmd="ssh.pl"
+    export cuda_cmd="ssh.pl"
+    export decode_cmd="ssh.pl"
+
+# This is an example of specifying several unique options in the JHU CLSP cluster setup.
+# Users can modify/add their own command options according to their cluster environments.
+elif [ "${cmd_backend}" = jhu ]; then
+
+    export train_cmd="queue.pl --mem 2G"
+    export cuda_cmd="queue-freegpu.pl --mem 2G --gpu 1 --config conf/queue.conf"
+    export decode_cmd="queue.pl --mem 4G"
+
+else
+    echo "$0: Error: Unknown cmd_backend=${cmd_backend}" 1>&2
+    return 1
+fi

UniAudio/UniAudio/egs/SE/data_scripts/create_data_json.py

@@ -0,0 +1,42 @@
+import json
+import argparse
+import sys
+import os
+from utils.task_definition import task_formats
+
+def main(cmd):
+    # parse the task first
+    possible_tasks = list(task_formats.keys())
+    parser = argparse.ArgumentParser(
+        description="Build the data json file for data loading",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--task", type=str, choices=possible_tasks, help="exact task")
+    parser.add_argument("--out-json", type=str, help="output json file")
+    args, _ = parser.parse_known_args(cmd)
+
+    # add arguments according to the task
+    task_format = task_formats[args.task]
+    required_files = task_format['keys'] + task_format['features']
+    for key in required_files:
+        parser.add_argument(f"--{key}", type=str, required=True)
+    args = parser.parse_args(cmd)
+
+    # replace the key / feature list by the corresponding key-value dict
+    keys = {k: getattr(args, k) for k in task_format['keys']}
+    features = {k: getattr(args, k) for k in task_format['features']}
+
+    task_format['keys'] = keys
+    task_format['features'] = features
+    task_format["task"] = args.task
+
+    # save as a json
+    with open(args.out_json, 'wb') as f:
+        f.write(
+            json.dumps(
+                task_format, indent=4, ensure_ascii=False, sort_keys=False
+            ).encode("utf_8")
+        )
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

UniAudio/UniAudio/egs/SE/data_scripts/filter_pt.py

@@ -0,0 +1,17 @@
+import torch
+import sys
+
+ref_file = sys.argv[1]
+out_pt_file = sys.argv[2]
+in_pt_files = sys.argv[3:]
+
+ref_dict = open(ref_file).readlines()
+ref_dict = {line.strip().split()[0]: None for line in ref_dict}
+
+pt = {}
+for f in in_pt_files:
+    this_dict = torch.load(f)
+    this_dict = {k: v for k, v in this_dict.items() if k in ref_dict}
+    pt.update(this_dict)
+
+torch.save(pt, out_pt_file)

UniAudio/UniAudio/egs/SE/data_scripts/filter_scp.py

@@ -0,0 +1,29 @@
+import sys
+
+ref_f = sys.argv[1]
+in_f = sys.argv[2]
+try:
+    writer = open(sys.argv[3], 'w', encoding='utf-8')
+    stream_out = False
+except:
+    stream_out = True 
+
+# output is in the order of ref_f
+ref = []
+for line in open(ref_f, encoding='utf-8'):
+    uttid = line.strip().split()[0]
+    ref.append(uttid)
+
+in_dic = {}
+for line in open(in_f, encoding='utf-8'):
+    elems = line.strip().split()
+    uttid = elems[0]
+    ctx = " ".join(elems[1:])
+    in_dic[uttid] = ctx
+
+for e in ref:
+    if e in in_dic:
+        if stream_out:
+            print(f"{e} {in_dic[e]}")
+        else:
+            writer.write(f"{e} {in_dic[e]}\n")

UniAudio/UniAudio/egs/SE/data_scripts/find_peer_utts.py

@@ -0,0 +1,45 @@
+import sys
+import argparse
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        description="output a file this specifies all peer utterances of each utts",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--utt2spk", type=str, help="original spk2utt file")
+    parser.add_argument("--peer-utts", type=str, help="revised spk2utt file")
+    parser.add_argument("--subset-list", type=str, help="list of utt subset")
+    return parser
+
+def main(args):
+    args = get_parser().parse_args(args)
+
+    # subset utts
+    subset_utts = open(args.subset_list).readlines()
+    subset_utts = [line.strip().split()[0] for line in subset_utts]
+
+    # utt2spk
+    utt2spk = open(args.utt2spk).readlines()
+    utt2spk = [line.strip().split() for line in utt2spk]
+    utt2spk = {line[0]: line[1] for line in utt2spk}
+
+    # utt2spk
+    spk2utt = {}
+    for utt, spk in utt2spk.items():
+        if spk not in spk2utt:
+            spk2utt[spk] = []
+        spk2utt[spk].append(utt)
+
+    writer = open(args.peer_utts, 'w') 
+    for utt in utt2spk.keys():
+        spk = utt2spk[utt]
+        peer_utts = spk2utt[spk]
+
+        if len(peer_utts) <= 1:
+            print(f'warning: utt {utt} has no peer speech except itself')
+
+        out_str = " ".join([utt] + peer_utts)
+        writer.write(out_str + "\n")
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

UniAudio/UniAudio/egs/SE/data_scripts/merge_then_split.py

@@ -0,0 +1,105 @@
+# UniAudio Teams
+import sys
+import torch
+import argparse
+import logging
+import tarfile
+import mmap
+import pickle
+import librosa
+from io import BytesIO
+from kaldiio import ReadHelper
+from tools.tokenizer.soundstream.AudioTokenizer import AudioTokenizer
+from tools.tokenizer.soundstream.EncodecTokenizer import EncodecTokenizer
+from tools.tokenizer.Text2Phone.Text2PhoneTokenizer import Text2PhoneTokenizer
+from tools.tokenizer.BPE.SPTokenizer import BPETokenizer
+from tools.tokenizer.Semantic.Semantic_tokenizer import SemanticTokenizer
+from tools.tokenizer.phone.phone_tokenizer import PhoneTokenizer
+from tools.tokenizer.Text_Image.BPETokenizer import BPETokenizer as ClipBPETokenizer
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        description="convert a data list, do tokenization and save as a torch .pt file",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--input-file", type=str, default=None, help="the previous .pt save path")
+    parser.add_argument("--key-word", type=str, default=None, help="the key word to choose file")
+    parser.add_argument("--split-file", type=str, default=None, help="the reference file for split operation")
+    return parser
+
+def main(args):
+    logging.basicConfig(
+        stream=sys.stdout,
+        level=logging.DEBUG,
+        format=f"%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s",
+    )
+    args = get_parser().parse_args(args)
+    data_dict = {}
+    
+    names = os.listdir(args.input_file)
+    for name in names:
+
+    if args.input_file is not None:
+        iterator = open(args.input_file)
+        for i, line in enumerate(open(args.input_file)):
+            line = line.strip().split()
+            key, value = line[0], " ".join(line[1:])
+            value = tokenizer.tokenize(value)
+            if value == None:
+                logging.error(f"an error instance: {key} {value}")
+                continue
+            if isinstance(value, torch.Tensor):
+                # may not be true for continuous tokenizer
+                # Keep this assertion at this moment.
+                assert value.dim() == 1
+                value = value.cpu()
+            data_dict[key] = value
+            if i > 0 and i % 1000 == 0:
+                logging.info(f"processed {i} examples")
+    elif args.tar_file is not None:
+        # we use tar as chunk
+        iterator = open(args.input_file)
+        for i, line in enumerate(open(args.input_file)):
+            tar_path = line.strip() # 
+            tar_o = tarfile.open(tar_path, mode='r')
+            for info in tar_o_1: # get the speech info
+                if info.name.split(".")[-1] == args.tar_key_word:
+                    cur_f = tar_o_1.extractfile(info)
+                    try:
+                        cur, _ = librosa.load(BytesIO(pickle.load(cur_f).item()), sr=16000)
+                    except:
+                        logging.error(f"an error instance: {tar_path} {info.name}")
+                        cur = None
+                    if cur is None:
+                        continue
+                    wav = torch.from_numpy(cur).unsqueeze(0) # transfer to (1,len)
+                    value = tokenizer.tokenize(wav)
+                    if value == None:
+                        logging.error(f"an error instance: {key} {value}")
+                        continue
+                    if isinstance(value, torch.Tensor):
+                        # may not be true for continuous tokenizer
+                        # Keep this assertion at this moment.
+                        assert value.dim() == 1
+                        value = value.cpu()
+                    data_dict[key] = value
+                    if i > 0 and i % 100 == 0:
+                        logging.info(f"processed {i} examples")
+    else:
+        # kaldiio format
+        assert isinstance(tokenizer, AudioTokenizer)
+        iterator = ReadHelper('scp:'+args.wav_scp, args.segments)
+        count = 0
+        for key, (sr, value) in iterator:
+            value = torch.from_numpy(value.copy())  / 32768 # [channel, samples]
+            value = value.unsqueeze(0)
+            value = tokenizer.tokenize(value)
+            data_dict[key] = value
+            if count > 0 and count % 100 == 0:
+                logging.info(f"processed {count} examples")
+            count += 1
+
+    torch.save(data_dict, args.output_file)
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

UniAudio/UniAudio/egs/SE/data_scripts/offline_tokenization.py

@@ -0,0 +1,161 @@
+# Author: # UniAudio Teams
+
+import sys
+import torch
+import argparse
+import logging
+import tarfile
+import mmap
+import pickle
+import librosa
+from io import BytesIO
+from kaldiio import ReadHelper
+from tools.tokenizer.soundstream.AudioTokenizer import AudioTokenizer
+from tools.tokenizer.soundstream.EncodecTokenizer import EncodecTokenizer
+from tools.tokenizer.BPE.SPTokenizer import BPETokenizer
+from tools.tokenizer.Semantic.Semantic_tokenizer import SemanticTokenizer
+from tools.tokenizer.phone.phone_tokenizer import PhoneTokenizer
+def get_parser():
+    parser = argparse.ArgumentParser(
+        description="convert a data list, do tokenization and save as a torch .pt file",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--input-file", type=str, default=None, help="text file in the format <exampe_id> <content>")
+    parser.add_argument("--tar-file", type=str, default=None, help="we use tar chunk to save audio information")
+    parser.add_argument("--tar-key-word", type=str, default=None, help="the key word to find file from tar")
+    parser.add_argument("--tar-info", type=str, default=None, help="the file to save tar information")
+    parser.add_argument("--wav-scp", type=str, default=None, help="kaldi wav.scp file")
+    parser.add_argument("--segments", type=str, default=None, help="kaldi segment file")
+    parser.add_argument("--output-file", type=str, help="dict")
+    parser.add_argument("--tokenizer", type=str, choices=['audio', 'g2p', 'bpe', 'semantic', 'encodec', 'alignment'], help="what tokenizer to use")
+    parser.add_argument("--rank", type=int, help="local GPU rank, if applicable")
+    parser.add_argument("--batch-size", type=int, default=1, help="for batch tokenization")
+    return parser
+
+def main(args):
+    logging.basicConfig(
+        stream=sys.stdout,
+        level=logging.DEBUG,
+        format=f"%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s",
+    )
+    args = get_parser().parse_args(args)
+    args.rank -= 1 # run.pl starts from 1 but the exact jobid / gpuid starts from 0   
+    max_gpu = torch.cuda.device_count()
+    args.rank = (args.rank % max_gpu) #
+
+    if args.tokenizer in ['audio', 'semantic', 'encodec']:
+        device = torch.device(f"cuda:{args.rank}")
+    else:
+        device = torch.device('cpu')
+    logging.info(f"Using device: {device}")
+
+    if args.tokenizer in ['g2p', 'bpe', 'alignment', "clipbpe"]:
+        assert args.wav_scp is None, f"when using {args.tokenizer}"
+        assert args.batch_size == 1, f"{args.tokenizer} doesn't support batch tokenization"
+
+    # GPU tokenizers 
+    if args.tokenizer == "audio":
+        tokenizer = AudioTokenizer(device=device)
+    elif args.tokenizer == "encodec":
+        tokenizer = EncodecTokenizer(device=device)
+    elif args.tokenizer == "semantic":
+        tokenizer = SemanticTokenizer(device=device)
+    # CPU tokenizers
+    elif args.tokenizer == "g2p":
+        pass
+        #tokenizer = Text2PhoneTokenizer()
+    elif args.tokenizer == "bpe":
+        tokenizer = BPETokenizer()
+    elif args.tokenizer == "alignment":
+        tokenizer = PhoneTokenizer(duplicate=True)
+    else:
+        raise NotImplementedError
+    tokenizer = tokenizer.to(device)
+    logging.info('tokenizer built')
+    data_dict = {}
+    assert not (args.input_file is not None and args.wav_scp is not None)
+    # TODO: support batch inference
+    if args.input_file is not None:
+        iterator = open(args.input_file)
+        s_cnt = 0
+        for i, line in enumerate(open(args.input_file)):
+            try:
+                line = line.strip().split()
+                key, value = line[0], " ".join(line[1:])
+                value = tokenizer.tokenize(value)
+                if value == None:
+                    logging.error(f"an error instance: {key} {value}")
+                    continue
+                if isinstance(value, torch.Tensor):
+                    # may not be true for continuous tokenizer
+                    # Keep this assertion at this moment.
+                    assert value.dim() == 1
+                    value = value.cpu()
+                data_dict[key] = value
+                s_cnt += 1
+                if i > 0 and i % 1000 == 0:
+                    logging.info(f"processed {s_cnt} examples")
+            except:
+                logging.error(f"an error instance: {line}")
+    elif args.tar_file is not None:
+        # we use tar as chunk
+        #iterator = open(args.tar_file)
+        f_info = open(args.tar_info, 'w')
+        for i, line in enumerate(open(args.tar_file,'r')):
+            tar_path = line.strip().split(' ')[-1] # 
+            try:
+                tar_o = tarfile.open(tar_path, mode='r')
+                for info in tar_o: # get the speech info
+                    # print('tar_path ', tar_path)
+                    if info.name.split(".")[-1] == args.tar_key_word:
+                        key = ' '.join(info.name.split(".")[:-1]) # 
+                        tar_new_name = tar_path.replace('','')
+                        tar_new_name = tar_new_name.replace('/', '_')[:-4]
+                        key = tar_new_name+'_'+key
+                        print('key ', key, info.name)
+                        # assert 1==2
+                        cur_f = tar_o.extractfile(info)
+                        # cur, _ = librosa.load(BytesIO(pickle.load(cur_f).item()), sr=16000)
+                        # print('cur ', cur.shape)
+                        try:
+                            cur = pickle.load(cur_f)
+                            #cur, _ = librosa.load(BytesIO(pickle.load(cur_f).item()), sr=16000)
+                        except:
+                            logging.error(f"an error instance: {tar_path} {info.name}")
+                            cur = None
+                        if cur is None:
+                            continue
+                        wav = torch.from_numpy(cur).unsqueeze(0).float() # transfer to (1,len)
+                        value = tokenizer.tokenize(wav)
+                        if value == None:
+                            logging.error(f"an error instance: {key} {value}")
+                            continue
+                        if isinstance(value, torch.Tensor):
+                            # may not be true for continuous tokenizer
+                            # Keep this assertion at this moment.
+                            assert value.dim() == 1
+                            value = value.cpu()
+                        data_dict[key] = value
+                        f_info.write(key+'\n')
+                        if i > 0 and i % 1 == 0:
+                            logging.info(f"processed {i} examples")
+                tar_o.close()
+            except:
+                logging.error(f"an error instance: {tar_path}")
+    else:
+        # kaldiio format
+        assert isinstance(tokenizer, AudioTokenizer)
+        iterator = ReadHelper('scp:'+args.wav_scp, args.segments)
+        count = 0
+        for key, (sr, value) in iterator:
+            value = torch.from_numpy(value.copy())  / 32768 # [channel, samples]
+            value = value.unsqueeze(0)
+            value = tokenizer.tokenize(value)
+            data_dict[key] = value
+            if count > 0 and count % 100 == 0:
+                logging.info(f"processed {count} examples")
+            count += 1
+    torch.save(data_dict, args.output_file)
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

UniAudio/UniAudio/egs/SE/data_scripts/select_spk2utt.py

@@ -0,0 +1,31 @@
+import sys
+import argparse
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        description="Revise the spk2utt file: it only contans a subset of the utts",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--in-spk2utt", type=str, help="original spk2utt file")
+    parser.add_argument("--out-spk2utt", type=str, help="revised spk2utt file")
+    parser.add_argument("--subset-list", type=str, help="list of utt subset")
+    return parser
+
+def main(args):
+    args = get_parser().parse_args(args)
+
+    utts = open(args.subset_list).readlines()
+    utts = [line.strip().split()[0] for line in utts]
+    utts = {x: None for x in utts}
+
+    writer = open(args.out_spk2utt, 'w') 
+    for line in open(args.in_spk2utt):
+        line = line.strip().split()
+        spk_id, spk_utts = line[0], line[1:]
+        spk_utts = [utt for utt in spk_utts if utt in utts]
+
+        out_str = " ".join([spk_id] + spk_utts)
+        writer.write(out_str + "\n")
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

UniAudio/UniAudio/egs/SE/local/data.sh

@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+
+set -e
+set -u
+set -o pipefail
+
+log() {
+    local fname=${BASH_SOURCE[1]##*/}
+    echo -e "$(date '+%Y-%m-%dT%H:%M:%S') (${fname}:${BASH_LINENO[0]}:${FUNCNAME[1]}) $*"
+}
+SECONDS=0
+
+stage=-1
+stop_stage=1
+trim_all_silence=false
+
+log "$0 $*"
+. utils/parse_options.sh
+
+if [ $# -ne 0 ]; then
+    log "Error: No positional arguments are required."
+    exit 2
+fi
+
+. ./path.sh || exit 1;
+. ./cmd.sh || exit 1;
+
+if [ -z "${LIBRITTS}" ]; then
+   log "Fill the value of 'LIBRITTS' of db.sh"
+   exit 1
+fi
+db_root=${LIBRITTS}
+data_url=www.openslr.org/resources/60
+
+if [ ${stage} -le -1 ] && [ ${stop_stage} -ge -1 ]; then
+    log "stage -1: local/donwload_and_untar.sh"
+    # download the original corpus
+    if [ ! -e "${db_root}"/LibriTTS/.complete ]; then
+        for part in dev-clean dev-other test-clean test-other train-clean-100 train-clean-360 train-other-500; do
+            local/download_and_untar.sh "${db_root}" "${data_url}" "${part}" &
+        done; wait
+        touch "${db_root}/LibriTTS/.complete"
+    else
+        log "Already done. Skiped."
+    fi
+
+    # download the additional labels
+    if [ ! -e "${db_root}"/LibriTTS/.lab_complete ]; then
+        # git clone https://github.com/kan-bayashi/LibriTTSCorpusLabel.git "${db_root}/LibriTTSCorpusLabel"
+        cat "${db_root}"/LibriTTSCorpusLabel/lab.tar.gz-* > "${db_root}/LibriTTS/lab.tar.gz"
+        cwd=$(pwd)
+        cd "${db_root}/LibriTTS"
+        for part in dev-clean dev-other test-clean test-other train-clean-100 train-clean-360 train-other-500; do
+            gunzip -c lab.tar.gz | tar xvf - "lab/phone/${part}" --strip-components=2 & 
+        done; wait
+        touch .lab_complete
+        # rm -rf lab.tar.gz
+        cd "${cwd}"
+    else
+        log "Already done. Skiped."
+    fi
+fi
+
+if [ ${stage} -le 0 ] && [ ${stop_stage} -ge 0 ]; then
+    log "stage 0: local/data_prep.sh"
+    if "${trim_all_silence}"; then
+        [ ! -e data/local ] && mkdir -p data/local
+        cp ${db_root}/LibriTTS/SPEAKERS.txt data/local
+    fi
+    for name in "dev-clean" "test-clean" "train-clean-100" "train-clean-360" "train-other-500"; do
+        (if "${trim_all_silence}"; then
+            # Remove all silence and re-create wav file
+            local/trim_all_silence.py "${db_root}/LibriTTS/${name}" data/local/${name}
+
+            # Copy normalized txt files while keeping the structure
+            cwd=$(pwd)
+            cd "${db_root}/LibriTTS/${name}"
+            find . -follow -name "*.normalized.txt" -print0 \
+                | tar c --null -T - -f - | tar xf - -C "${cwd}/data/local/${name}"
+            cd "${cwd}"
+
+            # Create kaldi data directory with the trimed audio
+            local/data_prep.sh "data/local/${name}" "data/${name}"
+        else
+            # Create kaldi data directory with the original audio
+            local/data_prep.sh "${db_root}/LibriTTS/${name}" "data/${name}"
+        fi
+	utils/fix_data_dir.sh "data/${name}") &
+    done; wait
+fi
+
+if [ ${stage} -le 1 ] && [ ${stop_stage} -ge 1 ]; then
+    log "stage 1: utils/combine_data.sh"
+    utils/combine_data.sh data/train-960 data/train-clean-100 data/train-clean-360 data/train-other-500
+fi
+
+log "Successfully finished. [elapsed=${SECONDS}s]"

UniAudio/UniAudio/egs/SE/local/data_prep.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+
+# Copyright 2014  Vassil Panayotov
+#           2014  Johns Hopkins University (author: Daniel Povey)
+# Modifications Copyright 2019  Nagoya University (author: Takenori Yoshimura)
+# Apache 2.0
+
+if [ "$#" -ne 2 ]; then
+  echo "Usage: $0 <src-dir> <dst-dir>"
+  echo "e.g.: $0 /export/a15/vpanayotov/data/LibriTTS/dev-clean data/dev-clean"
+  exit 1
+fi
+
+src=$1
+dst=$2
+
+spk_file=$src/../SPEAKERS.txt
+
+mkdir -p $dst || exit 1
+
+[ ! -d $src ] && echo "$0: no such directory $src" && exit 1
+[ ! -f $spk_file ] && echo "$0: expected file $spk_file to exist" && exit 1
+
+
+wav_scp=$dst/wav.scp; [[ -f "$wav_scp" ]] && rm $wav_scp
+trans=$dst/text; [[ -f "$trans" ]] && rm $trans
+utt2spk=$dst/utt2spk; [[ -f "$utt2spk" ]] && rm $utt2spk
+spk2gender=$dst/spk2gender; [[ -f $spk2gender ]] && rm $spk2gender
+
+for reader_dir in $(find -L $src -mindepth 1 -maxdepth 1 -type d | sed -e "s/$/_/" | sort); do
+  reader_dir=$(echo $reader_dir | sed -e "s/_$//")
+  reader=$(basename $reader_dir)
+  if ! [ $reader -eq $reader ]; then  # not integer.
+    echo "$0: unexpected subdirectory name $reader"
+    exit 1
+  fi
+
+  reader_gender=$(egrep "^$reader[ ]+\|" $spk_file | awk -F'|' '{gsub(/[ ]+/, ""); print tolower($2)}')
+  if [ "$reader_gender" != 'm' ] && [ "$reader_gender" != 'f' ]; then
+    echo "Unexpected gender: '$reader_gender'"
+    exit 1
+  fi
+
+  for chapter_dir in $(find -L $reader_dir/ -mindepth 1 -maxdepth 1 -type d | sort); do
+    chapter=$(basename $chapter_dir)
+    if ! [ "$chapter" -eq "$chapter" ]; then
+      echo "$0: unexpected chapter-subdirectory name $chapter"
+      exit 1
+    fi
+
+    spk="${reader}_${chapter}"
+
+    find -L $chapter_dir/ -iname "*.wav" | sort | while read -r wav_file; do
+       id=$(basename $wav_file .wav)
+       echo "$id $wav_file" >>$wav_scp
+
+       txt=$(cat $(echo $wav_file | sed -e "s/\.wav$/.normalized.txt/"))
+       echo "$id $txt" >>$trans
+
+       # NOTE: For now we are using per-chapter utt2spk. That is each chapter is considered
+       #       to be a different speaker. This is done for simplicity and because we want
+       #       e.g. the CMVN to be calculated per-chapter
+       echo "$id $spk" >>$utt2spk
+    done
+
+    # reader -> gender map (again using per-chapter granularity)
+    echo "$spk $reader_gender" >>$spk2gender
+  done
+done
+
+spk2utt=$dst/spk2utt
+utils/utt2spk_to_spk2utt.pl <$utt2spk >$spk2utt || exit 1
+
+ntrans=$(wc -l <$trans)
+nutt2spk=$(wc -l <$utt2spk)
+! [ "$ntrans" -eq "$nutt2spk" ] && \
+  echo "Inconsistent #transcripts($ntrans) and #utt2spk($nutt2spk)" && exit 1
+
+utils/validate_data_dir.sh --no-feats $dst || exit 1
+
+echo "$0: successfully prepared data in $dst"
+
+exit 0

UniAudio/UniAudio/egs/SE/local/download_and_untar.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+
+# Copyright   2014  Johns Hopkins University (author: Daniel Povey)
+# Modifications Copyright   2019  Nagoya University (author: Takenori Yoshimura)
+# Apache 2.0
+
+remove_archive=false
+
+if [ "$1" == --remove-archive ]; then
+  remove_archive=true
+  shift
+fi
+
+if [ $# -ne 3 ]; then
+  echo "Usage: $0 [--remove-archive] <data-base> <url-base> <corpus-part>"
+  echo "e.g.: $0 /export/a15/vpanayotov/data www.openslr.org/resources/60 dev-clean"
+  echo "With --remove-archive it will remove the archive after successfully un-tarring it."
+  echo "<corpus-part> can be one of: dev-clean, test-clean, dev-other, test-other,"
+  echo "          train-clean-100, train-clean-360, train-other-500."
+  exit 1
+fi
+
+data=$1
+url=$2
+part=$3
+
+if [ ! -d "$data" ]; then
+  echo "$0: no such directory $data"
+  exit 1
+fi
+
+part_ok=false
+list="dev-clean test-clean dev-other test-other train-clean-100 train-clean-360 train-other-500"
+for x in $list; do
+  if [ "$part" == $x ]; then part_ok=true; fi
+done
+if ! $part_ok; then
+  echo "$0: expected <corpus-part> to be one of $list, but got '$part'"
+  exit 1
+fi
+
+if [ -z "$url" ]; then
+  echo "$0: empty URL base."
+  exit 1
+fi
+
+if [ -f $data/LibriTTS/$part/.complete ]; then
+  echo "$0: data part $part was already successfully extracted, nothing to do."
+  exit 0
+fi
+
+
+# sizes of the archive files in bytes.
+sizes="1291469655 924804676 1230670113 964502297 7723686890 27504073644 44565031479"
+
+if [ -f $data/$part.tar.gz ]; then
+  size=$(/bin/ls -l $data/$part.tar.gz | awk '{print $5}')
+  size_ok=false
+  for s in $sizes; do if [ $s == $size ]; then size_ok=true; fi; done
+  if ! $size_ok; then
+    echo "$0: removing existing file $data/$part.tar.gz because its size in bytes $size"
+    echo "does not equal the size of one of the archives."
+    rm $data/$part.tar.gz
+  else
+    echo "$data/$part.tar.gz exists and appears to be complete."
+  fi
+fi
+
+if [ ! -f $data/$part.tar.gz ]; then
+  if ! which wget >/dev/null; then
+    echo "$0: wget is not installed."
+    exit 1
+  fi
+  full_url=$url/$part.tar.gz
+  echo "$0: downloading data from $full_url.  This may take some time, please be patient."
+
+  if ! wget -P $data --no-check-certificate $full_url; then
+    echo "$0: error executing wget $full_url"
+    exit 1
+  fi
+fi
+
+if ! tar -C $data -xvzf $data/$part.tar.gz; then
+  echo "$0: error un-tarring archive $data/$part.tar.gz"
+  exit 1
+fi
+
+touch $data/LibriTTS/$part/.complete
+
+echo "$0: Successfully downloaded and un-tarred $data/$part.tar.gz"
+
+if $remove_archive; then
+  echo "$0: removing $data/$part.tar.gz file since --remove-archive option was supplied."
+  rm $data/$part.tar.gz
+fi

UniAudio/UniAudio/egs/SE/local/trim_all_silence.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+
+# Copyright 2020 Tomoki Hayashi
+#  Apache 2.0  (http://www.apache.org/licenses/LICENSE-2.0)
+
+"""Trim silence in the audio and re-create wav files."""
+
+import argparse
+import fnmatch
+import logging
+import os
+import sys
+
+import numpy as np
+import soundfile as sf
+
+
+def find_files(root_dir, query="*.wav", include_root_dir=True):
+    """Find files recursively.
+
+    Args:
+        root_dir (str): Root root_dir to find.
+        query (str): Query to find.
+        include_root_dir (bool): If False, root_dir name is not included.
+
+    Returns:
+        list: List of found filenames.
+
+    """
+    files = []
+    for root, dirnames, filenames in os.walk(root_dir, followlinks=True):
+        for filename in fnmatch.filter(filenames, query):
+            files.append(os.path.join(root, filename))
+    if not include_root_dir:
+        files = [file_.replace(root_dir + "/", "") for file_ in files]
+
+    return files
+
+
+def main():
+    """Run trimming."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--max_sp_length",
+        default=0.05,
+        type=float,
+        help="maximum length of shortpose in the middle of utterances",
+    )
+    parser.add_argument(
+        "--after_sp_length",
+        default=0.05,
+        type=float,
+        help="length of offset after shortpose",
+    )
+    parser.add_argument("db_root", type=str, help="root path of NKY corpus")
+    parser.add_argument(
+        "target_dir", type=str, help="directory to save the trimmed audio"
+    )
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        stream=sys.stdout,
+        format="%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
+    )
+
+    db_root = args.db_root
+    target_dir = args.target_dir
+    max_sp_length = args.max_sp_length
+    after_sp_length = args.after_sp_length
+    wavfiles = sorted(find_files(db_root, include_root_dir=False))
+    labfiles = [f.replace(".wav", ".lab") for f in wavfiles]
+
+    for idx, (wavfile, labfile) in enumerate(zip(wavfiles, labfiles)):
+        if not os.path.exists(f"{db_root}/{labfile}"):
+            logging.warning(f"{labfile} does not exist. skipped.")
+            continue
+        x, fs = sf.read(f"{db_root}/{wavfile}")
+        with open(f"{db_root}/{labfile}") as f:
+            lines = [line.replace("\n", "") for line in f.readlines()]
+        start_times = [float(line.split("\t")[0]) for line in lines]
+        end_times = [float(line.split("\t")[1]) for line in lines]
+        labels = [line.split("\t")[2] for line in lines]
+        start_idxs = [int(t * fs) for t in start_times]
+        end_idxs = [int(t * fs) for t in end_times]
+
+        new_x = []
+        prev_label = None
+        prev_sp_legnth = 0.0
+        for start_idx, end_idx, label in zip(start_idxs, end_idxs, labels):
+            if label == "sil" or len(label) == 0:
+                continue
+            elif label in ["sp", "spn"]:
+                sp_length = (end_idx - start_idx) / fs
+                if sp_length > max_sp_length:
+                    end_idx = start_idx + int(max_sp_length * fs)
+                prev_sp_legnth = sp_length
+            elif prev_label in ["sp", "spn"]:
+                if prev_sp_legnth > after_sp_length + max_sp_length:
+                    start_idx -= int(after_sp_length * fs)
+            new_x += [x[start_idx:end_idx]]
+            prev_label = label
+        new_x = np.concatenate(new_x).reshape(-1)
+        write_path = f"{target_dir}/{wavfile}"
+        os.makedirs(os.path.dirname(write_path), exist_ok=True)
+        sf.write(f"{target_dir}/{wavfile}", new_x, fs)
+
+        if (idx + 1) % 1000 == 0:
+            logging.info(f"Now processing... ({idx + 1}/{len(wavfiles)})")
+
+
+if __name__ == "__main__":
+    main()

UniAudio/UniAudio/egs/SE/make_noisy.py

@@ -0,0 +1,205 @@
+# This code aims to prepare SE training data, which use clean wave and nosie wave to simulate nosiy speech.
+import os 
+import random
+import math
+import csv
+import argparse
+import librosa
+import soundfile as sf
+import io
+import numpy as np
+
+import mmap
+import os
+import soundfile as sf
+
+def mmap_read(path: str, offset: int, length: int) -> bytes:
+    with open(path, "rb") as f:
+        with mmap.mmap(f.fileno(), length=0, access=mmap.ACCESS_READ) as mmap_o:
+            data = mmap_o[offset : offset + length]
+    return data
+
+def read_from_stored_zip(zip_path: str, offset: int, length: int) -> bytes:
+    return mmap_read(zip_path, offset, length)
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        description="helping to simulate speech enhancement data",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--clean-file", type=str, default=None, help="clean file in the format <exampe_id> <path>")
+    parser.add_argument("--noise-file", type=str, default=None, help="noise file in the format <example_id> <path>")
+    parser.add_argument("--noisy-path", type=str, default=None, help="the path to save noisy audio")
+    parser.add_argument("--clean-path", type=str, default=None, help="the path to save noisy audio")
+    parser.add_argument("--output-file", type=str, help="the output file, which records the noisy and clean information")
+    return parser
+
+def parse_filelist(file_path):
+    '''
+    解析txt路径文件
+    '''
+    files = []
+    f = open(file_path,'r')
+    for d in f.readlines():
+        if d[-1] == "\n":
+            files.append(d[:-1])
+        else:
+            files.append(d)
+    return files
+
+def load_audio_from_path(file_path):
+    '''根据路径读取音频文件 '''
+    '''
+    audio_obj= wavio.read(file_path)
+    audio = audio_obj.data[:,0].astype(np.float32)
+    assert audio_obj.rate == 16000
+    '''
+    audio,sr = librosa.load(file_path, sr=16000)
+    assert sr == 16000
+    #print(audio_obj.sampwidth,audio_obj)
+    #audio = wavfile.read(file_path)[1]
+    #audio = audio / 32768 #2^15
+    #audio = librosa.load(file_path,sr=16000)[0]
+    #audio,fs= torchaudio.load(file_path,sr=16000)
+    #assert fs == 16000
+    #audio = audio.numpy()
+    return audio
+
+def sparse_chunk_file(file_path):
+    ans = file_path.split(':')
+    return ans[0], ans[1], ans[2]
+
+def load_audio_from_chunks(file_path):
+    ph, st, ed = sparse_chunk_file(file_path)
+    byte_data = read_from_stored_zip(ph, int(st), int(ed))
+    wav_path = io.BytesIO(byte_data)
+    waveform, sample_rate = sf.read(wav_path, dtype="float32") # 
+    return waveform
+
+def split_wave_into2g(waveform):
+    if waveform.shape[0] > 14*16000:
+        waveform1 = waveform[:7*16000]
+        waveform2 = waveform[7*16000:14*16000] # 
+    else:
+        waveform1 = waveform[:int(waveform.shape[0])//2]
+        waveform2 = waveform[int(waveform.shape[0])//2:]
+    return waveform1, waveform2
+
+def save_audio_to_path(audio,store_path):
+    '''将音频文件存储在给定路径下'''
+    sf.write(store_path,audio, 16000,subtype='PCM_16')
+    #wavfile.write(store_path, 16000, audio*32768)
+    #wavio.write(store_path,audio,16000,sampwidth=2)
+
+def SNR2scale(clean,noise,snr):
+    clean_power = (clean**2).mean()
+    noise_power = (noise**2).mean()
+    
+    scale = (
+                10 ** (-snr / 20)
+                * np.sqrt(clean_power)
+                / np.sqrt(max(noise_power, 1e-10))
+            )
+    return scale
+
+def mix_clean_noise_full(clean,noise,snr):
+    '''
+    给定纯净语音和噪声片段，基于一定的信噪比
+    对clean和noise进行对齐并叠加
+    '''
+    mix_audio = np.zeros(clean.shape)
+
+    print('mix:',mix_audio.shape,'noise:',noise.shape,'clean:',clean.shape)
+
+    if clean.shape[0] >= noise.shape[0]:#如果纯净语音比带噪语音长
+        offset = np.random.randint(0,2 * clean.shape[-1] - noise.shape[-1])
+        # Repeat noise，先将噪声补齐至两倍长
+        noise = np.pad(noise,[(offset, 2 * clean.shape[-1] - noise.shape[-1] - offset)],mode="wrap")
+    #然后所有的流程都需要走这一分支
+    #即：对于现在比原始音频长度长的噪声文件，随机选取start进行裁剪
+    start = np.random.randint(0,noise.shape[-1]-clean.shape[-1])
+    noise = noise[start:start+clean.shape[-1]]
+    scale = SNR2scale(clean,noise,snr)#calculating after align the noise audio with the clean one
+    noise = scale * noise
+    #store the noise audio
+    
+    mix_audio = clean + noise
+    return mix_audio,noise
+
+def main_full_with_path():
+    #write log in csv file
+    args = get_parser().parse_args()
+    mix_tr_rt = args.noisy_path # 
+    clean_tr_rt = args.clean_path # 
+    tr_csv = args.output_file
+    f = open(tr_csv,'w',encoding = 'utf-8',newline = "")
+    csv_write = csv.writer(f)
+    csv_write.writerow(['clean','noise','snr','clean_path','noisy_path'])
+
+    clean_rt = args.clean_file
+    noise_rt = args.noise_file
+
+    clean_lists = parse_filelist(clean_rt)
+    noise_lists = parse_filelist(noise_rt)
+    
+    noise_nums = len(noise_lists)
+ 
+    SNR_ends = [-20, 40]
+    cnt = 0
+    set_duration = 7
+    #SNRs = [-20,-16,-12,-8,-4,0,4,8,12,16,20,24,28,32,36,40]
+    for clean_path in clean_lists:
+        clean_audio = load_audio_from_chunks(clean_path)
+        #print('clean_audio ', clean_audio.shape)
+        clean_audio1, clean_audio2 = split_wave_into2g(clean_audio)
+        # print('clean_audio1, clean_audio2', clean_audio1.shape, clean_audio2.shape)
+        # assert 1==2
+        if clean_audio1.shape[0] < set_duration*16000:
+            continue
+        #clean_audio = load_audio_from_path(clean_path)
+        noise_indexes = set()
+        clean_audios = [clean_audio1, clean_audio2]
+        for i, c_a in enumerate(clean_audios):
+            noise_idx = random.randint(0,noise_nums-1)
+            noise_path = noise_lists[noise_idx]
+            noise = load_audio_from_path(noise_path)
+            # print('noise ', noise.shape, c_a.shape)
+            # assert 1==2
+            n_zero = np.zeros(set_duration*16000)
+            c_zero = np.zeros(set_duration*16000)
+            if noise.shape[0] > set_duration*16000:
+                idx = random.randint(0, noise.shape[0]-set_duration*16000-1)
+                n_zero = noise[idx:idx+set_duration*16000] # 最多只用8s
+            else:
+                n_zero[:noise.shape[0]] = noise # 
+            if c_a.shape[0] > set_duration*16000:
+                idx = random.randint(0, c_a.shape[0]-set_duration*16000-1)
+                c_zero = c_a[idx:idx + set_duration*16000]
+            else:
+                c_zero[:c_a.shape[0]] = c_a # 
+            #select snr
+            snr = random.randint(SNR_ends[0],SNR_ends[1])
+            #snr = random.sample(SNRs,1)[0]
+            #TODO:现在的mix函数返回两个值，noisy和noise
+            mix_audio = mix_clean_noise_full(c_zero, n_zero, snr)[0]
+            # print('mix_audio ', mix_audio.shape, c_zero.shape)
+            # assert 1==2
+            ph = clean_path.replace(':', '_') # transfer the : into _
+            #sprint('ph ', ph, ph.split('/'))
+            clean_name = ph.split('/')[-1] # get the last item
+            print('clean_name ', clean_name)
+            new_clean_name = clean_name + '_'+str(i) # get the order
+            #clean_name和noise_name之间用'_'进行分隔
+            mix_name = os.path.join(mix_tr_rt, new_clean_name + '_'+noise_path.split('/')[-1])
+            print('mix_name:', mix_name)
+            clean_name = os.path.join(clean_tr_rt, new_clean_name) + '.wav'
+            #print('clean_name:', clean_name)
+            save_audio_to_path(mix_audio, mix_name)
+            save_audio_to_path(c_zero, clean_name)
+            csv_write.writerow([clean_name[:-4], noise_path.split('/')[-1][:-4], snr, clean_name, mix_name])
+            #print(clean_name[:-4],str(snr))
+        #assert 1==2
+    f.close()
+
+if __name__ == "__main__":
+    main_full_with_path()

UniAudio/UniAudio/egs/SE/path.sh

@@ -0,0 +1,9 @@
+export LC_ALL=C
+export PYTHONIOENCODING=UTF-8
+export OMP_NUM_THREADS=1
+
+# executable bins
+export PATH=$PATH:utils:../../tools/data_scripts/
+
+# python import root
+export PYTHONPATH=${PYTHONPATH}:../../

UniAudio/UniAudio/egs/SE/readme.md

@@ -0,0 +1,5 @@
+## Recipe for SE
+Firstly, prepare your data pair <noise_audio, clean_audio> . You can refer make_noisy.py code to prepare your own data.
+
+After you get clean and noise data. Using clean.scp and noise.scp file to record their waveform path: <br>
+```name wav_path```

UniAudio/UniAudio/egs/SE/run.sh

@@ -0,0 +1,206 @@
+
+# A demo recipe for SE
+# SE: noise audio --> clean audio
+. ./path.sh
+
+pip3 install fairseq==0.12.2 einops==0.6.0 sentencepiece encodec
+
+stage=1
+stop_stage=100
+ngpu=1  # how many GPUs, you want to use to train the model
+
+train_set="train"
+valid_set="val"
+test_sets=""
+
+# training config
+seed=999
+debug=false
+batch_scale=8000 # the total number of tokens in one batch
+learning_rate=0.005 # the learning rate
+port=12345
+train_opts=
+inference_opts=
+tag=
+inference_tag=default
+resume=
+data_tag=
+TASK='SE'
+
+if [ ! -d "utils" ]; then
+  ln -s ../tools/kaldi/utils ./
+fi
+if [ ! -d "data_scripts" ]; then
+  ln -s ../tools/data_scripts ./
+fi
+
+. utils/parse_options.sh
+
+if [ ! -z $resume ]; then
+    train_opts="--resume $resume"
+    inference_opts="--resume $resume"
+fi
+
+if [ $debug == true ]; then
+    export HOST_GPU_NUM=1
+    export HOST_NUM=1
+    export NODE_NUM=1
+    export INDEX=0
+    export CHIEF_IP="localhost"
+    train_opts="$train_opts"
+
+else
+    export HOST_GPU_NUM=8
+    export HOST_NUM=1
+    export NODE_NUM=1
+    export INDEX=0
+    export CHIEF_IP="localhost"
+    train_opts="$train_opts"
+fi
+
+### stage 1-3: data preparation ###
+
+# Prepare data following Espnet and split
+if [ ${stage} -le 1 ] && [ ${stop_stage} -ge 1 ]; then
+    echo "Prepare SE dataset"
+    # this part aims to get the information about the dataset. 
+    # prepare wav.scp and noise.scp
+fi
+
+if [ ${stage} -le 2 ] && [ ${stop_stage} -ge 2 ]; then
+    echo "split the data for $ngpu GPUs"
+
+    for part in $test_sets $valid_set $train_set; do
+      mkdir -p data/${part}/${ngpu}splits
+      # extra shuf to ensure balance across GPUs
+      # So the generated data cannot be reproduced due to the shuffle randomness
+      cat data/${part}/wav.scp | shuf >  data/${part}/wav.scp.shuf
+      split_scp=
+      for n in `seq 1 $ngpu`; do
+          split_scp="$split_scp data/${part}/${ngpu}splits/wav.${n}.scp"
+      done
+      utils/split_scp.pl data/${part}/wav.scp.shuf $split_scp
+
+
+    done
+fi
+
+# Plain TTS requires 2 data keys: phone_seq, audio_seq
+# stage 2-3 process audio_seq and phone_seq respectively
+if [ ${stage} -le 3 ] && [ ${stop_stage} -ge 3 ]; then
+    echo "Prepare audio sequence"
+    for part in $valid_set $train_set; do
+    # for part in $valid_set; do
+      echo "prepare $part ... "
+
+      # split noise.scp based on clean.scp
+      utils/run.pl JOB=1:$ngpu data/${part}/${ngpu}splits/log/filter_noise.JOB.log \
+        python3 data_scripts/filter_scp.py \
+          data/${part}/${ngpu}splits/wav.JOB.scp data/${part}/noise.scp \
+          data/${part}/${ngpu}splits/noise.JOB.scp || exit 1;
+
+      # clean Audio
+      utils/run.pl JOB=1:$ngpu data/${part}/${ngpu}splits/log/audio_codec_dump.JOB.log \
+        python3 data_scripts/offline_tokenization.py \
+          --input-file data/${part}/${ngpu}splits/wav.JOB.scp \
+          --output-file data/${part}/${ngpu}splits/clean_codec.JOB.pt \
+          --tokenizer audio --rank JOB || exit 1;
+
+      # noise Audio
+      utils/run.pl JOB=1:$ngpu data/${part}/${ngpu}splits/log/noise_codec_dump.JOB.log \
+        python3 data_scripts/offline_tokenization.py \
+          --input-file data/${part}/${ngpu}splits/noise.JOB.scp \
+          --output-file data/${part}/${ngpu}splits/noise_codec.JOB.pt \
+          --tokenizer audio --rank JOB || exit 1;
+      
+    done
+fi
+
+if [ ${stage} -le 4 ] && [ ${stop_stage} -ge 4 ]; then
+    echo "create data json"
+    # json index from 0 but all data files index from 1
+    for part in $valid_set $train_set; do
+      for n in `seq 0 $[$ngpu-1]`; do
+        # TTS
+        python3 data_scripts/create_data_json.py \
+         --task SE \
+         --out-json   $PWD/data/${part}/${ngpu}splits/data_se.${n}.json \
+         --noise_seq  $PWD/data/${part}/${ngpu}splits/noise_codec.$[$n+1].pt \
+         --audio_seq  $PWD/data/${part}/${ngpu}splits/audio_codec.$[$n+1].pt \
+         & 
+      done; wait
+
+    done
+fi
+
+### Stage 4: Training ###
+if [ -z $data_tag ] && [ $stop_stage -le 4 ]; then
+    echo "you should provide data tag" || exit 1;
+fi
+
+train_data_jsons="data/${train_set}/${ngpu}splits/data_se.ALL.json"
+valid_data_jsons="data/${valid_set}/${ngpu}splits/data_se.ALL.json"
+
+if [ ${stage} -le 5 ] && [ ${stop_stage} -ge 5 ]; then
+    mkdir -p exp 
+    if [ -z $tag ]; then
+        echo "please provide a tag for this experiment" && exit 1;
+    fi
+    echo "stage 5: training..."
+    NCCL_DEBUG=TRACE torchrun \
+        --nproc_per_node ${HOST_GPU_NUM} --master_port $port \
+        --nnodes=${HOST_NUM} --node_rank=${INDEX} --master_addr=${CHIEF_IP} \
+        ../../train.py \
+        --exp_dir exp \
+        --seed $seed \
+        --cudnn_deterministic \
+        --train_data_jsons $train_data_jsons \
+        --valid_data_jsons $valid_data_jsons \
+        --batch_scale $batch_scale \
+        --learning_rate $learning_rate \
+        --non-acoustic-repeat 3 \
+        --audio-tokenizer "soundstream" \
+        --audio-prompt-tokenizer "audio_prompt" \
+        --phone-tokenizer "alignment" \
+        --semantic-tokenizer "hubert" \
+        --semantic-tokenizer-duplicate true \
+        --singPhoneTokenizer "sing_phone" \
+        --singMidiTokenizer "sing_midi" \
+        --FrozenT5Embedder "text_t5" \
+        --n_layer 24 \
+        --n_head 16 \
+        --n_embd 1536 \
+        $train_opts
+fi
+
+# SE inference
+vc_test_sets="se_test"
+inference_tag="se_inference"
+inference_dir=exp/${tag}/inference_${inference_tag}
+ngpu=1
+if [ ${stage} -le 6 ] && [ ${stop_stage} -ge 6 ]; then
+    echo "stage 2: TTS  inference ..."
+    mkdir -p ${inference_dir}
+    for part in $vc_test_sets; do
+        mkdir -p ${inference_dir}/${part}
+        echo "inference on set: ${part}"
+        data_json="data.JOB.json" # your val set .json file
+
+        utils/run.pl --max-jobs-run 8 JOB=0:$[${ngpu}-1] \
+          ${inference_dir}/${part}/inference.JOB.log \
+          python3 ../../infer.py \
+            --exp_dir exp/${tag} \
+            --rank JOB \
+	          --inference_mode 'sampling' \
+            --n_samples 1 \
+            --seed 888 \
+            --rank JOB \
+	          --data_json $data_json \
+            --generate_target audio \
+            --fixed_length False \
+            --maxlen_ratio 7 \
+            --minlen_ratio 0.5 \
+	          --output_dir ${inference_dir}/${part}/JOB \
+            $inference_opts
+    done
+fi

UniAudio/UniAudio/egs/SE/utils/add_disambig.pl

@@ -0,0 +1,58 @@
+#!/usr/bin/env perl
+# Copyright 2010-2011 Microsoft Corporation
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+# WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+# MERCHANTABLITY OR NON-INFRINGEMENT.
+# See the Apache 2 License for the specific language governing permissions and
+# limitations under the License.
+
+
+# Adds some specified number of disambig symbols to a symbol table.
+# Adds these as #1, #2, etc.
+# If the --include-zero option is specified, includes an extra one
+# #0.
+
+$include_zero = 0;
+if($ARGV[0] eq "--include-zero") {
+    $include_zero = 1;
+    shift @ARGV;
+}
+
+if(@ARGV != 2) {
+    die "Usage: add_disambig.pl [--include-zero] symtab.txt num_extra > symtab_out.txt ";
+}
+
+
+$input = $ARGV[0];
+$nsyms = $ARGV[1];
+
+open(F, "<$input") || die "Opening file $input";
+
+while(<F>) {
+    @A = split(" ", $_);
+    @A == 2 || die "Bad line $_";
+    $lastsym = $A[1];
+    print;
+}
+
+if(!defined($lastsym)){
+ die "Empty symbol file?";
+}
+
+if($include_zero) {
+    $lastsym++;
+    print "#0  $lastsym\n";
+}
+
+for($n = 1; $n <= $nsyms; $n++) {
+    $y = $n + $lastsym;
+    print "#$n  $y\n";
+}

UniAudio/UniAudio/egs/SE/utils/add_lex_disambig.pl

@@ -0,0 +1,196 @@
+#!/usr/bin/env perl
+#  Copyright 2010-2011  Microsoft Corporation
+#            2013-2016  Johns Hopkins University (author: Daniel Povey)
+#                 2015  Hainan Xu
+#                 2015  Guoguo Chen
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+# WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+# MERCHANTABLITY OR NON-INFRINGEMENT.
+# See the Apache 2 License for the specific language governing permissions and
+# limitations under the License.
+
+
+# Adds disambiguation symbols to a lexicon.
+# Outputs still in the normal lexicon format.
+# Disambig syms are numbered #1, #2, #3, etc. (#0
+# reserved for symbol in grammar).
+# Outputs the number of disambig syms to the standard output.
+# With the --pron-probs option, expects the second field
+# of each lexicon line to be a pron-prob.
+# With the --sil-probs option, expects three additional
+# fields after the pron-prob, representing various components
+# of the silence probability model.
+
+$pron_probs = 0;
+$sil_probs = 0;
+$first_allowed_disambig = 1;
+
+for ($n = 1; $n <= 3 && @ARGV > 0; $n++) {
+  if ($ARGV[0] eq "--pron-probs") {
+    $pron_probs = 1;
+    shift @ARGV;
+  }
+  if ($ARGV[0] eq "--sil-probs") {
+    $sil_probs = 1;
+    shift @ARGV;
+  }
+  if ($ARGV[0] eq "--first-allowed-disambig") {
+    $first_allowed_disambig = 0 + $ARGV[1];
+    if ($first_allowed_disambig < 1) {
+      die "add_lex_disambig.pl: invalid --first-allowed-disambig option: $first_allowed_disambig\n";
+    }
+    shift @ARGV;
+    shift @ARGV;
+  }
+}
+
+if (@ARGV != 2) {
+  die "Usage: add_lex_disambig.pl [opts] <lexicon-in> <lexicon-out>\n" .
+    "This script adds disambiguation symbols to a lexicon in order to\n" .
+    "make decoding graphs determinizable; it adds pseudo-phone\n" .
+    "disambiguation symbols #1, #2 and so on at the ends of phones\n" .
+    "to ensure that all pronunciations are different, and that none\n" .
+    "is a prefix of another.\n" .
+    "It prints to the standard output the number of the largest-numbered" .
+    "disambiguation symbol that was used.\n" .
+    "\n" .
+    "Options:   --pron-probs       Expect pronunciation probabilities in the 2nd field\n" .
+    "           --sil-probs        [should be with --pron-probs option]\n" .
+    "                              Expect 3 extra fields after the pron-probs, for aspects of\n" .
+    "                              the silence probability model\n" .
+    "           --first-allowed-disambig <n>  The number of the first disambiguation symbol\n" .
+    "                              that this script is allowed to add.  By default this is\n" .
+    "                              #1, but you can set this to a larger value using this option.\n" .
+    "e.g.:\n" .
+    " add_lex_disambig.pl lexicon.txt lexicon_disambig.txt\n" .
+    " add_lex_disambig.pl --pron-probs lexiconp.txt lexiconp_disambig.txt\n" .
+    " add_lex_disambig.pl --pron-probs --sil-probs lexiconp_silprob.txt lexiconp_silprob_disambig.txt\n";
+}
+
+
+$lexfn = shift @ARGV;
+$lexoutfn = shift @ARGV;
+
+open(L, "<$lexfn") || die "Error opening lexicon $lexfn";
+
+# (1)  Read in the lexicon.
+@L = ( );
+while(<L>) {
+    @A = split(" ", $_);
+    push @L, join(" ", @A);
+}
+
+# (2) Work out the count of each phone-sequence in the
+# lexicon.
+
+foreach $l (@L) {
+    @A = split(" ", $l);
+    shift @A; # Remove word.
+    if ($pron_probs) {
+      $p = shift @A;
+      if (!($p > 0.0 && $p <= 1.0)) { die "Bad lexicon line $l (expecting pron-prob as second field)"; }
+    }
+    if ($sil_probs) {
+      $silp = shift @A;
+      if (!($silp > 0.0 && $silp <= 1.0)) { die "Bad lexicon line $l for silprobs"; }
+      $correction = shift @A;
+      if ($correction <= 0.0) { die "Bad lexicon line $l for silprobs"; }
+      $correction = shift @A;
+      if ($correction <= 0.0) { die "Bad lexicon line $l for silprobs"; }
+    }
+    if (!(@A)) {
+      die "Bad lexicon line $1, no phone in phone list";
+    }
+    $count{join(" ",@A)}++;
+}
+
+# (3) For each left sub-sequence of each phone-sequence, note down
+# that it exists (for identifying prefixes of longer strings).
+
+foreach $l (@L) {
+    @A = split(" ", $l);
+    shift @A; # Remove word.
+    if ($pron_probs) { shift @A; } # remove pron-prob.
+    if ($sil_probs) {
+      shift @A; # Remove silprob
+      shift @A; # Remove silprob
+      shift @A; # Remove silprob, there three numbers for sil_probs
+    }
+    while(@A > 0) {
+        pop @A;  # Remove last phone
+        $issubseq{join(" ",@A)} = 1;
+    }
+}
+
+# (4) For each entry in the lexicon:
+#  if the phone sequence is unique and is not a
+#  prefix of another word, no diambig symbol.
+#  Else output #1, or #2, #3, ... if the same phone-seq
+#  has already been assigned a disambig symbol.
+
+
+open(O, ">$lexoutfn") || die "Opening lexicon file $lexoutfn for writing.\n";
+
+# max_disambig will always be the highest-numbered disambiguation symbol that
+# has been used so far.
+$max_disambig = $first_allowed_disambig - 1;
+
+foreach $l (@L) {
+  @A = split(" ", $l);
+  $word = shift @A;
+  if ($pron_probs) {
+    $pron_prob = shift @A;
+  }
+  if ($sil_probs) {
+    $sil_word_prob = shift @A;
+    $word_sil_correction = shift @A;
+    $prev_nonsil_correction = shift @A
+  }
+  $phnseq = join(" ", @A);
+  if (!defined $issubseq{$phnseq}
+      && $count{$phnseq} == 1) {
+    ;                           # Do nothing.
+  } else {
+    if ($phnseq eq "") {        # need disambig symbols for the empty string
+      # that are not use anywhere else.
+      $max_disambig++;
+      $reserved_for_the_empty_string{$max_disambig} = 1;
+      $phnseq = "#$max_disambig";
+    } else {
+      $cur_disambig = $last_used_disambig_symbol_of{$phnseq};
+      if (!defined $cur_disambig) {
+        $cur_disambig = $first_allowed_disambig;
+      } else {
+        $cur_disambig++;           # Get a number that has not been used yet for
+                                   # this phone sequence.
+      }
+      while (defined $reserved_for_the_empty_string{$cur_disambig}) {
+        $cur_disambig++;
+      }
+      if ($cur_disambig > $max_disambig) {
+        $max_disambig = $cur_disambig;
+      }
+      $last_used_disambig_symbol_of{$phnseq} = $cur_disambig;
+      $phnseq = $phnseq . " #" . $cur_disambig;
+    }
+  }
+  if ($pron_probs) {
+    if ($sil_probs) {
+      print O "$word\t$pron_prob\t$sil_word_prob\t$word_sil_correction\t$prev_nonsil_correction\t$phnseq\n";
+    } else {
+      print O "$word\t$pron_prob\t$phnseq\n";
+    }
+  } else {
+    print O "$word\t$phnseq\n";
+  }
+}
+
+print $max_disambig . "\n";

UniAudio/UniAudio/egs/SE/utils/analyze_segments.pl

@@ -0,0 +1,43 @@
+#!/usr/bin/perl
+# Copyright 2015 GoVivace Inc. (Author: Nagendra Kumar Goel)
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+# WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+# MERCHANTABLITY OR NON-INFRINGEMENT.
+# See the Apache 2 License for the specific language governing permissions and
+# limitations under the License.
+
+# Analyze a segments file and print important stats on it.
+
+$dur = $total = 0;
+$maxDur = 0;
+$minDur = 9999999999;
+$n = 0;
+while(<>){
+    chomp;
+    @t = split(/\s+/);
+    $dur = $t[3] - $t[2];
+    $total += $dur;
+    if ($dur > $maxDur) {
+        $maxSegId = $t[0];
+        $maxDur = $dur;
+    }
+    if ($dur < $minDur) {
+        $minSegId = $t[0];
+        $minDur = $dur;
+    }
+    $n++;
+}
+$avg=$total/$n;
+$hrs = $total/3600;
+print "Total $hrs hours of data\n";
+print "Average segment length $avg seconds\n";
+print "Segment $maxSegId has length of $maxDur seconds\n";
+print "Segment $minSegId has length of $minDur seconds\n";

UniAudio/UniAudio/egs/SE/utils/apply_map.pl

@@ -0,0 +1,97 @@
+#!/usr/bin/env perl
+use warnings; #sed replacement for -w perl parameter
+# Copyright 2012  Johns Hopkins University (Author: Daniel Povey)
+# Apache 2.0.
+
+# This program is a bit like ./sym2int.pl in that it applies a map
+# to things in a file, but it's a bit more general in that it doesn't
+# assume the things being mapped to are single tokens, they could
+# be sequences of tokens.  See the usage message.
+
+
+$permissive = 0;
+
+for ($x = 0; $x <= 2; $x++) {
+
+  if (@ARGV > 0 && $ARGV[0] eq "-f") {
+    shift @ARGV;
+    $field_spec = shift @ARGV;
+    if ($field_spec =~ m/^\d+$/) {
+      $field_begin = $field_spec - 1; $field_end = $field_spec - 1;
+    }
+    if ($field_spec =~ m/^(\d*)[-:](\d*)/) { # accept e.g. 1:10 as a courtesty (properly, 1-10)
+      if ($1 ne "") {
+        $field_begin = $1 - 1;  # Change to zero-based indexing.
+      }
+      if ($2 ne "") {
+        $field_end = $2 - 1;    # Change to zero-based indexing.
+      }
+    }
+    if (!defined $field_begin && !defined $field_end) {
+      die "Bad argument to -f option: $field_spec";
+    }
+  }
+
+  if (@ARGV > 0 && $ARGV[0] eq '--permissive') {
+    shift @ARGV;
+    # Mapping is optional (missing key is printed to output)
+    $permissive = 1;
+  }
+}
+
+if(@ARGV != 1) {
+  print STDERR "Invalid usage: " . join(" ", @ARGV) . "\n";
+  print STDERR <<'EOF';
+Usage: apply_map.pl [options] map <input >output
+ options: [-f <field-range> ] [--permissive]
+   This applies a map to some specified fields of some input text:
+   For each line in the map file: the first field is the thing we
+   map from, and the remaining fields are the sequence we map it to.
+   The -f (field-range) option says which fields of the input file the map
+   map should apply to.
+   If the --permissive option is supplied, fields which are not present
+   in the map will be left as they were.
+ Applies the map 'map' to all input text, where each line of the map
+ is interpreted as a map from the first field to the list of the other fields
+ Note: <field-range> can look like 4-5, or 4-, or 5-, or 1, it means the field
+ range in the input to apply the map to.
+ e.g.: echo A B | apply_map.pl a.txt
+ where a.txt is:
+ A a1 a2
+ B b
+ will produce:
+ a1 a2 b
+EOF
+  exit(1);
+}
+
+($map_file) = @ARGV;
+open(M, "<$map_file") || die "Error opening map file $map_file: $!";
+
+while (<M>) {
+  @A = split(" ", $_);
+  @A >= 1 || die "apply_map.pl: empty line.";
+  $i = shift @A;
+  $o = join(" ", @A);
+  $map{$i} = $o;
+}
+
+while(<STDIN>) {
+  @A = split(" ", $_);
+  for ($x = 0; $x < @A; $x++) {
+    if ( (!defined $field_begin || $x >= $field_begin)
+         && (!defined $field_end || $x <= $field_end)) {
+      $a = $A[$x];
+      if (!defined $map{$a}) {
+        if (!$permissive) {
+          die "apply_map.pl: undefined key $a in $map_file\n";
+        } else {
+          print STDERR "apply_map.pl: warning! missing key $a in $map_file\n";
+        }
+      } else {
+        $A[$x] = $map{$a};
+      }
+    }
+  }
+  print join(" ", @A) . "\n";
+}

UniAudio/UniAudio/egs/SE/utils/best_wer.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+#
+# Copyright 2010-2011 Microsoft Corporation
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+# THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+# WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+# MERCHANTABLITY OR NON-INFRINGEMENT.
+# See the Apache 2 License for the specific language governing permissions and
+# limitations under the License.
+
+# To be run from one directory above this script.
+
+perl -e 'while(<>){ 
+    s/\|(\d)/\| $1/g; s/(\d)\|/$1 \|/g;
+    if (m/[WS]ER (\S+)/ && (!defined $bestwer || $bestwer > $1)){ $bestwer = $1; $bestline=$_; } # kaldi "compute-wer" tool.
+    elsif (m: (Mean|Sum/Avg|)\s*\|\s*\S+\s+\S+\s+\|\s+\S+\s+\S+\s+\S+\s+\S+\s+(\S+)\s+\S+\s+\|:
+        && (!defined $bestwer || $bestwer > $2)){ $bestwer = $2; $bestline=$_; } }  # sclite.
+   if (defined $bestline){ print $bestline; } ' | \
+  awk 'BEGIN{ FS="%WER"; } { if(NF == 2) { print FS$2" "$1; } else { print $0; }}' | \
+  awk 'BEGIN{ FS="Sum/Avg"; } { if(NF == 2) { print $2" "$1; } else { print $0; }}' | \
+  awk '{ if($1!~/%WER/) { print "%WER "$9" "$0; } else { print $0; }}' | \
+  sed -e 's|\s\s*| |g' -e 's|\:$||' -e 's|\:\s*\|\s*$||'
+
+
+

UniAudio/UniAudio/egs/SE/utils/build_const_arpa_lm.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+
+# Copyright 2014  Guoguo Chen
+# Apache 2.0
+
+# This script reads in an Arpa format language model, and converts it into the
+# ConstArpaLm format language model.
+
+# begin configuration section
+# end configuration section
+
+[ -f path.sh ] && . ./path.sh;
+
+. utils/parse_options.sh
+
+if [ $# != 3 ]; then
+  echo "Usage: "
+  echo "  $0 [options] <arpa-lm-path> <old-lang-dir> <new-lang-dir>"
+  echo "e.g.:"
+  echo "  $0 data/local/lm/3-gram.full.arpa.gz data/lang/ data/lang_test_tgmed"
+  echo "Options"
+  exit 1;
+fi
+
+export LC_ALL=C
+
+arpa_lm=$1
+old_lang=$2
+new_lang=$3
+
+mkdir -p $new_lang
+
+mkdir -p $new_lang
+cp -r $old_lang/* $new_lang
+
+unk=`cat $old_lang/oov.int`
+bos=`grep "^<s>\s" $old_lang/words.txt | awk '{print $2}'`
+eos=`grep "^</s>\s" $old_lang/words.txt | awk '{print $2}'`
+if [[ -z $bos || -z $eos ]]; then
+  echo "$0: <s> and </s> symbols are not in $old_lang/words.txt"
+  exit 1
+fi
+if [[ -z $unk ]]; then
+  echo "$0: can't find oov symbol id in $old_lang/oov.int"
+  exit 1
+fi
+
+
+arpa-to-const-arpa --bos-symbol=$bos \
+  --eos-symbol=$eos --unk-symbol=$unk \
+  "gunzip -c $arpa_lm | utils/map_arpa_lm.pl $new_lang/words.txt|"  $new_lang/G.carpa  || exit 1;
+
+exit 0;

UniAudio/UniAudio/egs/SE/utils/build_kenlm_model_from_arpa.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+# 2020 author Jiayu DU
+# Apache 2.0
+
+# This script reads in an Arpa format language model, and converts it into the
+# KenLM format language model.
+
+[ -f path.sh ] && . ./path.sh;
+
+# begin configuration section
+kenlm_opts="" # e.g. "-q 8 -b 8" for 8bits quantization
+model_type="trie" # "trie" or "probing". trie is smaller, probing is faster.
+# end configuration section
+
+. utils/parse_options.sh
+
+if [ $# != 2 ]; then
+  echo "Usage: "
+  echo "  $0 [options] <arpa-lm-path> <kenlm-path>"
+  echo "e.g.:"
+  echo "  $0 data/local/lm/4gram.arpa data/lang_test/G.trie"
+  echo "Options:"
+  echo "  --model-type can be either \"trie\" or \"probing\""
+  echo "  --kenlm-opts directly pass through to kenlm"
+  echo "    e.g. for 8bits quantization, feed \"-q 8 -b 8\""
+  exit 1;
+fi
+
+export LC_ALL=C
+
+arpa_lm=$1
+kenlm=$2
+
+if ! which build_binary >& /dev/null ; then
+  echo "$0: cannot find KenLM's build_binary tool,"
+  echo "check kenlm installation (tools/extras/install_kenlm_query_only.sh)."
+  exit 1
+fi
+
+mkdir -p $(dirname $kenlm)
+build_binary  $kenlm_opts  $model_type  $arpa_lm  $kenlm
+
+echo "$0: Successfully built arpa into kenlm format: $kenlm"
+exit 0

UniAudio/UniAudio/egs/SE/utils/combine_data.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+# Copyright 2012  Johns Hopkins University (Author: Daniel Povey).  Apache 2.0.
+#           2014  David Snyder
+
+# This script combines the data from multiple source directories into
+# a single destination directory.
+
+# See http://kaldi-asr.org/doc/data_prep.html#data_prep_data for information
+# about what these directories contain.
+
+# Begin configuration section.
+extra_files= # specify additional files in 'src-data-dir' to merge, ex. "file1 file2 ..."
+skip_fix=false # skip the fix_data_dir.sh in the end
+# End configuration section.
+
+echo "$0 $@"  # Print the command line for logging
+
+if [ -f path.sh ]; then . ./path.sh; fi
+. parse_options.sh || exit 1;
+
+if [ $# -lt 2 ]; then
+  echo "Usage: combine_data.sh [--extra-files 'file1 file2'] <dest-data-dir> <src-data-dir1> <src-data-dir2> ..."
+  echo "Note, files that don't appear in all source dirs will not be combined,"
+  echo "with the exception of utt2uniq and segments, which are created where necessary."
+  exit 1
+fi
+
+dest=$1;
+shift;
+
+first_src=$1;
+
+rm -r $dest 2>/dev/null || true
+mkdir -p $dest;
+
+export LC_ALL=C
+
+for dir in $*; do
+  if [ ! -f $dir/utt2spk ]; then
+    echo "$0: no such file $dir/utt2spk"
+    exit 1;
+  fi
+done
+
+# Check that frame_shift are compatible, where present together with features.
+dir_with_frame_shift=
+for dir in $*; do
+  if [[ -f $dir/feats.scp && -f $dir/frame_shift ]]; then
+    if [[ $dir_with_frame_shift ]] &&
+       ! cmp -s $dir_with_frame_shift/frame_shift $dir/frame_shift; then
+      echo "$0:error: different frame_shift in directories $dir and " \
+           "$dir_with_frame_shift. Cannot combine features."
+      exit 1;
+    fi
+    dir_with_frame_shift=$dir
+  fi
+done
+
+# W.r.t. utt2uniq file the script has different behavior compared to other files
+# it is not compulsary for it to exist in src directories, but if it exists in
+# even one it should exist in all. We will create the files where necessary
+has_utt2uniq=false
+for in_dir in $*; do
+  if [ -f $in_dir/utt2uniq ]; then
+    has_utt2uniq=true
+    break
+  fi
+done
+
+if $has_utt2uniq; then
+  # we are going to create an utt2uniq file in the destdir
+  for in_dir in $*; do
+    if [ ! -f $in_dir/utt2uniq ]; then
+      # we assume that utt2uniq is a one to one mapping
+      cat $in_dir/utt2spk | awk '{printf("%s %s\n", $1, $1);}'
+    else
+      cat $in_dir/utt2uniq
+    fi
+  done | sort -k1 > $dest/utt2uniq
+  echo "$0: combined utt2uniq"
+else
+  echo "$0 [info]: not combining utt2uniq as it does not exist"
+fi
+# some of the old scripts might provide utt2uniq as an extrafile, so just remove it
+extra_files=$(echo "$extra_files"|sed -e "s/utt2uniq//g")
+
+# segments are treated similarly to utt2uniq. If it exists in some, but not all
+# src directories, then we generate segments where necessary.
+has_segments=false
+for in_dir in $*; do
+  if [ -f $in_dir/segments ]; then
+    has_segments=true
+    break
+  fi
+done
+
+if $has_segments; then
+  for in_dir in $*; do
+    if [ ! -f $in_dir/segments ]; then
+      echo "$0 [info]: will generate missing segments for $in_dir" 1>&2
+      utils/data/get_segments_for_data.sh $in_dir
+    else
+      cat $in_dir/segments
+    fi
+  done | sort -k1 > $dest/segments
+  echo "$0: combined segments"
+else
+  echo "$0 [info]: not combining segments as it does not exist"
+fi
+
+for file in utt2spk utt2lang utt2dur utt2num_frames reco2dur feats.scp text cmvn.scp vad.scp reco2file_and_channel wav.scp spk2gender $extra_files; do
+  exists_somewhere=false
+  absent_somewhere=false
+  for d in $*; do
+    if [ -f $d/$file ]; then
+      exists_somewhere=true
+    else
+      absent_somewhere=true
+      fi
+  done
+
+  if ! $absent_somewhere; then
+    set -o pipefail
+    ( for f in $*; do cat $f/$file; done ) | sort -k1 > $dest/$file || exit 1;
+    set +o pipefail
+    echo "$0: combined $file"
+  else
+    if ! $exists_somewhere; then
+      echo "$0 [info]: not combining $file as it does not exist"
+    else
+      echo "$0 [info]: **not combining $file as it does not exist everywhere**"
+    fi
+  fi
+done
+
+utils/utt2spk_to_spk2utt.pl <$dest/utt2spk >$dest/spk2utt
+
+if [[ $dir_with_frame_shift ]]; then
+  cp $dir_with_frame_shift/frame_shift $dest
+fi
+
+if ! $skip_fix ; then
+  utils/fix_data_dir.sh $dest || exit 1;
+fi
+
+exit 0

UniAudio/UniAudio/egs/SE/utils/convert_ctm.pl

@@ -0,0 +1,96 @@
+#!/usr/bin/env perl
+
+# Copyright 2012  Johns Hopkins University (Author: Daniel Povey).  Apache 2.0.
+
+# This takes as standard input a ctm file that's "relative to the utterance",
+# i.e. times are measured relative to the beginning of the segments, and it
+# uses a "segments" file (format:
+# utterance-id recording-id start-time end-time
+# ) and a "reco2file_and_channel" file (format:
+# recording-id basename-of-file
+
+$skip_unknown=undef;
+if ( $ARGV[0] eq "--skip-unknown" ) {
+  $skip_unknown=1;
+  shift @ARGV;
+}
+
+if (@ARGV < 2 || @ARGV > 3) {
+  print STDERR "Usage: convert_ctm.pl <segments-file> <reco2file_and_channel-file> [<utterance-ctm>] > real-ctm\n";
+  exit(1);
+}
+
+$segments = shift @ARGV;
+$reco2file_and_channel = shift @ARGV;
+
+open(S, "<$segments") || die "opening segments file $segments";
+while(<S>) {
+  @A = split(" ", $_);
+  @A == 4 || die "Bad line in segments file: $_";
+  ($utt, $recording_id, $begin_time, $end_time) = @A;
+  $utt2reco{$utt} = $recording_id;
+  $begin{$utt} = $begin_time;
+  $end{$utt} = $end_time;
+}
+close(S);
+open(R, "<$reco2file_and_channel") || die "open reco2file_and_channel file $reco2file_and_channel";
+while(<R>) {
+  @A = split(" ", $_);
+  @A == 3 || die "Bad line in reco2file_and_channel file: $_";
+  ($recording_id, $file, $channel) = @A;
+  $reco2file{$recording_id} = $file;
+  $reco2channel{$recording_id} = $channel;
+}
+
+
+# Now process the ctm file, which is either the standard input or the third
+# command-line argument.
+$num_done = 0;
+while(<>) {
+  @A= split(" ", $_);
+  ( @A == 5 || @A == 6 ) || die "Unexpected ctm format: $_";
+  # lines look like:
+  # <utterance-id> 1 <begin-time> <length> <word> [ confidence ]
+  ($utt, $one, $wbegin, $wlen, $w, $conf) = @A;
+  $reco = $utt2reco{$utt};
+  if (!defined $reco) { 
+      next if defined $skip_unknown;
+      die "Utterance-id $utt not defined in segments file $segments"; 
+  }
+  $file = $reco2file{$reco};
+  $channel = $reco2channel{$reco};
+  if (!defined $file || !defined $channel) { 
+    die "Recording-id $reco not defined in reco2file_and_channel file $reco2file_and_channel"; 
+  }
+  $b = $begin{$utt};
+  $e = $end{$utt};
+  $wbegin_r = $wbegin + $b; # Make it relative to beginning of the recording.
+  $wbegin_r = sprintf("%.2f", $wbegin_r);
+  $wlen = sprintf("%.2f", $wlen);
+  if (defined $conf) {
+    $line = "$file $channel $wbegin_r $wlen $w $conf\n"; 
+  } else {
+    $line = "$file $channel $wbegin_r $wlen $w\n"; 
+  }
+  if ($wbegin_r + $wlen > $e + 0.01) {
+    print STDERR "Warning: word appears to be past end of recording; line is $line";
+  }
+  print $line; # goes to stdout.
+  $num_done++;
+}
+
+if ($num_done == 0) { exit 1; } else { exit 0; }
+
+__END__
+
+# Test example [also test it without the 0.5's]
+echo utt reco 10.0 20.0 > segments
+echo reco file A > reco2file_and_channel
+echo utt 1 8.0 1.0 word 0.5 > ctm_in
+echo file A 18.00 1.00 word 0.5 > ctm_out
+utils/convert_ctm.pl segments reco2file_and_channel ctm_in | cmp - ctm_out || echo error
+rm segments reco2file_and_channel ctm_in ctm_out
+
+
+
+

UniAudio/UniAudio/egs/SE/utils/convert_slf.pl

@@ -0,0 +1,302 @@
+#!/usr/bin/env perl
+
+# Copyright 2014  Brno University of Technology (author Karel Vesely)
+# Copyright 2013  Korbinian Riedhammer
+
+# Convert a kaldi-lattice to HTK SLF format;  if given an output
+# directory, each lattice will be put in an individual gzipped file.
+
+# Internal representation of nodes, links:
+# node hash:
+# { W=>[word], t=>[time], n_out_arcs=>[number_of_outgoing_arcs] };
+# (Time internally represented as integer number of frames.)
+# link hash:
+# { S=>[start_node], E=>[end_node], W=>[word], v=>[0], a=>[acoustic_score], l=>[graph_score] }
+# 
+# The HTK output supports:
+# - words on links [default],
+#   - simpler, same as in kaldi lattices, node-ids in output correspond to kaldi lattices
+# - words on nodes,
+#   - apart from original nodes, there are extra nodes containing the words.
+#   - each original ark is replaced by word-node and two links, connecting it with original nodes.
+
+
+use utf8;
+use List::Util qw(max);
+
+binmode(STDIN, ":encoding(utf8)");
+binmode(STDOUT, ":encoding(utf8)");
+
+# defaults
+$framerate=0.01;
+$wordtonode=0;
+
+$usage="Convert kaldi lattices to HTK SLF (v1.1) format.\n".
+       "Usage: convert_slf.pl [options] lat-file.txt [out-dir]\n".
+       "  e.g. lattice-align-words lang/phones/word_boundary.int final.mdl 'ark:gunzip -c lat.gz |' ark,t:- | utils/int2sym.pl -f 3 lang/words.txt | $0 - slf/\n".
+       "\n".
+       "Options regarding the SLF output:\n".
+       "  --frame-rate x  Frame rate to compute timing information (default: $framerate)\n".
+       "  --word-to-node  Print the word symbols on nodes (adds extra nodes+links; default: words at links)\n".
+       "\n";
+
+# parse options
+while (@ARGV gt 0 and $ARGV[0] =~ m/^--/) {
+  $param = shift @ARGV;
+  if ($param eq "--frame-rate") { $framerate = shift @ARGV; }
+  elsif ($param eq "--word-to-node") { $wordtonode = 1;}
+  else {
+    print STDERR "Unknown option $param\n";
+    print STDERR;
+    print STDERR $usage;
+    exit 1;
+  }
+}
+
+# check positional arg count
+if (@ARGV < 1 || @ARGV > 2) {
+  print STDERR $usage;
+  exit 1;
+}
+
+# store gzipped lattices individually to outdir:
+$outdir = "";
+if (@ARGV == 2) {
+  $outdir = pop @ARGV;
+  unless (-d $outdir) { system("mkdir -p $outdir"); }
+  unless (-d $outdir) {
+    print STDERR "Could not create directory $outdir\n";
+    exit 1;
+  }
+}
+# or we'll print lattices to stdout:
+if ($outdir eq "") {
+  open(FH, ">-") or die "Could not write to stdout (???)\n";
+}
+
+
+### parse kaldi lattices:
+
+$utt = "";
+$arc = 0;
+$latest_time = 0.0;
+@links = ();
+%nodes = ();
+%nodes_extra = ();
+%accepting_states = ();
+
+open (FI, $ARGV[0]) or die "Could not read from file\n";
+binmode(FI, ":encoding(utf8)");
+
+while(<FI>) {
+  chomp;
+
+  @A = split /\s+/;
+
+  if (@A == 1 and $utt eq "") {
+    # new lattice
+    $utt = $A[0];
+    $nodes{0} = { W=>"!NULL", t=>0.0, n_out_arcs=>0 }; #initial node
+
+  } elsif (@A == 1) {
+    # accepting node without FST weight, store data for link to terminal super-state
+    $accepting_states{$A[0]} = { W=>"!NULL", v=>0, a=>0, l=>0 };
+
+  } elsif (@A == 2) {
+    # accepting state with FST weight on it, again store data for the link
+    ($s, $info) = @A;
+    ($gs, $as, $ss) = split(/,/, $info);
+
+    # kaldi saves -log, but HTK does it the other way round
+    $gs *= -1;
+    $as *= -1;
+
+    # the state sequence is something like 1_2_4_56_45, get number of tokens after splitting by '_':
+    $ss = scalar split(/_/, $ss);
+    
+    # update the end time
+    die "Node $s not yet visited, is lattice sorted topologically? $utt" unless exists $nodes{$s}{t};
+    $time_end = $nodes{$s}{t} + $ss;
+    if ($latest_time < $time_end) { $latest_time = $time_end; }
+
+    # add the link data
+    $accepting_states{$A[0]} = { W=>"!NULL", v=>0, a=>$as, l=>$gs };
+
+  } elsif (@A == 4 or @A == 3) {
+    # FSA arc
+    ($s, $e, $w, $info) = @A;
+    if ($info ne "") {
+      ($gs, $as, $ss) = split(/,/, $info);
+    } else {
+      $gs = 0; $as = 0; $ss = "";
+    }
+
+    # rename epsilons to null
+    $w = "!NULL" if $w eq "<eps>";
+
+    # kaldi saves -log, but HTK does it the other way round
+    $gs *= -1;
+    $as *= -1;
+    
+    # the state sequence is something like 1_2_4_56_45, get number of tokens after splitting by '_':
+    $ss = scalar split(/_/, $ss);
+    
+    # keep track of the number of outgoing arcs for each node 
+    # (later, we will connect sinks to the terminal state)
+    $nodes{$s}{n_out_arcs} += 1;
+
+    # keep track of timing
+    die "Node $s not yet visited, is lattice sorted topologically? $utt" unless exists $nodes{$s};
+    $time_end = $nodes{$s}{t} + $ss;
+    if ($latest_time < $time_end) { $latest_time = $time_end; }
+
+    # sanity check on already existing node
+    if (exists $nodes{$e}) {
+      die "Node $e previously stored with different time ".$nodes{$e}{t}." now $time_end, $utt.\n"
+       if $time_end ne $nodes{$e}{t};
+    }
+
+    # store internal representation of the arc
+    if (not $wordtonode) {
+      # The words on links, the lattice keeps it's original structure,
+      # add node; do not overwrite
+      $nodes{$e} = { t=>$time_end, n_out_arcs=>0 } unless defined $nodes{$e};
+      # add the link data
+      push @links, { S=>$s, E=>$e, W=>$w, v=>0, a=>$as, l=>$gs };
+
+    } else {
+      # The problem here was that, if we have a node with several incoming links,
+      # the links can have different words on it, so we cannot simply put word from 
+      # link into the node.
+      #
+      # The simple solution is:
+      # each FST arc gets replaced by extra node with word and two links,
+      # connecting it with original nodes.
+      #
+      # The lattice gets larger, and it is good to minimize the lattice during importing.
+      #
+      # During reading the FST, we don't know how many nodes there are in total, 
+      # so the extra nodes are stored separately, indexed by arc number, 
+      # and links have flags describing which type of node are they connected to.
+
+      # add 'extra node' containing the word:
+      $nodes_extra{$arc} = { W=>$w, t=>$time_end };
+      # add 'original node'; do not overwrite
+      $nodes{$e} = { W=>"!NULL", t=>$time_end, n_out_arcs=>0 } unless defined $nodes{$e};
+      
+      # add the link from 'original node' to 'extra node'
+      push @links, { S=>$s, E=>$arc, W=>$w, v=>0, a=>$as, l=>$gs, to_extra_node=>1 };
+      # add the link from 'extra node' to 'original node'
+      push @links, { S=>$arc, E=>$e, W=>$w, v=>0, a=>0, l=>0, from_extra_node=>1 };
+   
+      # increase arc counter 
+      $arc++;
+    }
+
+  } elsif (@A == 0) { # end of lattice reading, we'll add terminal super-state, and print it soon...
+    # find sinks
+    %sinks = ();
+    for $n (keys %nodes) { 
+      $sinks{$n} = 1 if ($nodes{$n}{n_out_arcs} == 0);
+    }
+
+    # sanity check: lattices need at least one sink!
+    if (scalar keys %sinks == 0) {
+      print STDERR "Error: $utt does not have at least one sink node-- cyclic lattice??\n";
+    }
+
+    # add terminal super-state,
+    $last_node = max(keys(%nodes)) + 1;
+    $nodes{$last_node} = { W=>"!NULL", t=>$latest_time };
+
+    # connect all accepting states with terminal super-state,
+    for $accept (sort { $a <=> $b } keys %accepting_states) {
+      %a = %{$accepting_states{$accept}};
+      push @links, { S=>$accept, E=>$last_node, W=>$a{W}, v=>$a{v}, a=>$a{a}, l=>$a{l} };
+    }
+
+    # connect also all sinks that are not accepting states,
+    for $sink (sort { $a <=> $b } keys %sinks) {
+      unless(exists($accepting_states{$sink})) {
+        print STDERR "WARNING: detected sink node which is not accepting state in lattice $utt, incomplete lattice?\n";
+        $a = \$accepting_states{$accept};
+        push @links, { S=>$accept, E=>$last_node, W=>"!NULL", v=>0, a=>0, l=>0 };
+      }
+    }
+
+    # print out the lattice;  open file handle first
+    unless ($outdir eq "") {
+      open(FH, "|-", "gzip -c > $outdir/$utt.lat.gz") or die "Could not write to $outdir/$utt.lat.gz\n";
+      binmode(FH, ":encoding(utf8)");
+    } 
+
+    if (not $wordtonode) {
+      # print lattice with words on links:
+      
+      # header
+      print FH "VERSION=1.1\n";
+      print FH "UTTERANCE=$utt\n";
+      print FH "N=".(keys %nodes)."\tL=".(@links)."\n";
+
+      # nodes
+      for $n (sort { $a <=> $b } keys %nodes) {
+        printf FH "I=%d\tt=%.2f\n", $n, $nodes{$n}{t}*$framerate;
+      }
+
+      # links/arks
+      for $i (0 .. $#links) {
+        %l = %{$links[$i]}; # get hash representing the link...
+        printf FH "J=$i\tS=%d\tE=%d\tW=%s\tv=%f\ta=%f\tl=%f\n", $l{S}, $l{E}, $l{W}, $l{v}, $l{a}, $l{l};
+      }
+
+    } else {
+      # print lattice with words in the nodes:
+
+      # header
+      print FH "VERSION=1.1\n";
+      print FH "UTTERANCE=$utt\n";
+      print FH "N=".(scalar(keys(%nodes))+scalar(keys(%nodes_extra)))."\tL=".(@links)."\n";
+
+      # number of original nodes, offset of extra_nodes
+      $node_id_offset = scalar keys %nodes;
+
+      # nodes
+      for $n (sort { $a <=> $b } keys %nodes) {
+        printf FH "I=%d\tW=%s\tt=%.2f\n", $n, $nodes{$n}{W}, $nodes{$n}{t}*$framerate;
+      }
+      # extra nodes
+      for $n (sort { $a <=> $b } keys %nodes_extra) {
+        printf FH "I=%d\tW=%s\tt=%.2f\n", $n+$node_id_offset, $nodes_extra{$n}{W}, $nodes_extra{$n}{t}*$framerate;
+      }
+
+      # links/arks
+      for $i (0 .. $#links) {
+        %l = %{$links[$i]}; # get hash representing the link...
+        if ($l{from_extra_node}) { $l{S} += $node_id_offset; }
+        if ($l{to_extra_node}) { $l{E} += $node_id_offset; }
+        printf FH "J=$i\tS=%d\tE=%d\tv=%f\ta=%f\tl=%f\n", $l{S}, $l{E}, $l{v}, $l{a}, $l{l};
+      }
+    }
+
+    print FH "\n";
+
+    # close handle if it was a file
+    close(FH) unless ($outdir eq "");
+
+    # clear data
+    $utt = "";
+    $arc = 0;
+    $latest_time = 0.0;
+    @links = ();
+    %nodes = ();
+    %nodes_extra = ();
+    %accepting_states = ();
+  } else {
+    die "Unexpected column number of input line\n$_";
+  }
+}
+
+if ($utt != "") {
+  print STDERR "Last lattice was not printed as it might be incomplete?  Missing empty line?\n";
+}
+

UniAudio/UniAudio/egs/SE/utils/convert_slf_parallel.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+# Copyright Brno University of Technology (Author: Karel Vesely) 2014.  Apache 2.0.
+
+# This script converts lattices to HTK format compatible with other toolkits.
+# We can choose to put words to nodes or arcs, as both is valid in the SLF format.
+
+# begin configuration section.
+cmd=run.pl
+dirname=lats-in-htk-slf
+parallel_opts="--max-jobs-run 50" # We should limit disk stress
+word_to_node=false # Words in arcs or nodes? [default:arcs]
+#end configuration section.
+
+echo "$0 $@"
+
+[ -f ./path.sh ] && . ./path.sh
+. parse_options.sh || exit 1;
+
+if [ $# -ne 3 ]; then
+  echo "Usage: $0 [options] <data-dir> <lang-dir|graph-dir> <decode-dir>"
+  echo " Options:"
+  echo "    --cmd (run.pl|queue.pl...)      # specify how to run the sub-processes."
+  echo "    --word-to-link (true|false)     # put word symbols on links or nodes."
+  echo "    --parallel-opts STR             # parallelization options (def.: '--max-jobs-run 50')."
+  echo "e.g.:"
+  echo "$0 data/dev data/lang exp/tri4a/decode_dev"
+  exit 1;
+fi
+
+data=$1
+lang=$2 # Note: may be graph directory not lang directory, but has the necessary stuff copied.
+dir=$3
+
+model=$(dirname $dir)/final.mdl # assume model one level up from decoding dir.
+
+for f in $lang/words.txt $lang/phones/align_lexicon.int $model $dir/lat.1.gz; do
+  [ ! -f $f ] && echo "$0: expecting file $f to exist" && exit 1;
+done
+
+[ ! -d $dir/$dirname/log ] && mkdir -p $dir/$dirname
+
+echo "$0: Converting lattices into '$dir/$dirname'"
+
+# Words in arcs or nodes? [default:nodes]
+word_to_link_arg=
+$word_to_node && word_to_node_arg="--word-to-node"
+
+nj=$(cat $dir/num_jobs)
+
+# convert the lattices (individually, gzipped)
+$cmd $parallel_opts JOB=1:$nj $dir/$dirname/log/lat_convert.JOB.log \
+  mkdir -p $dir/$dirname/JOB/ '&&' \
+  lattice-align-words-lexicon --output-error-lats=true --output-if-empty=true \
+    $lang/phones/align_lexicon.int $model "ark:gunzip -c $dir/lat.JOB.gz |" ark,t:- \| \
+  utils/int2sym.pl -f 3 $lang/words.txt \| \
+  utils/convert_slf.pl $word_to_node_arg - $dir/$dirname/JOB/ || exit 1
+
+# make list of lattices
+find -L $PWD/$dir/$dirname -name *.lat.gz > $dir/$dirname/lat_htk.scp || exit 1
+
+# check number of lattices:
+nseg=$(cat $data/segments | wc -l)
+nlat_out=$(cat $dir/$dirname/lat_htk.scp | wc -l)
+echo "segments $nseg, saved-lattices $nlat_out"
+#
+[ $nseg -ne $nlat_out ] && echo "WARNING: missing $((nseg-nlat_out)) lattices for some segments!" \
+  && exit 1
+
+echo "success, converted lats to HTK : $PWD/$dir/$dirname/lat_htk.scp"
+exit 0
+

UniAudio/UniAudio/egs/SE/utils/copy_data_dir.sh

@@ -0,0 +1,149 @@
+#!/usr/bin/env bash
+
+# Copyright 2013  Johns Hopkins University (author: Daniel Povey)
+# Apache 2.0
+
+# This script operates on a directory, such as in data/train/,
+# that contains some subset of the following files:
+#  feats.scp
+#  wav.scp
+#  vad.scp
+#  spk2utt
+#  utt2spk
+#  text
+#
+# It copies to another directory, possibly adding a specified prefix or a suffix
+# to the utterance and/or speaker names.  Note, the recording-ids stay the same.
+#
+
+
+# begin configuration section
+spk_prefix=
+utt_prefix=
+spk_suffix=
+utt_suffix=
+validate_opts=   # should rarely be needed.
+# end configuration section
+
+. utils/parse_options.sh
+
+if [ $# != 2 ]; then
+  echo "Usage: "
+  echo "  $0 [options] <srcdir> <destdir>"
+  echo "e.g.:"
+  echo " $0 --spk-prefix=1- --utt-prefix=1- data/train data/train_1"
+  echo "Options"
+  echo "   --spk-prefix=<prefix>     # Prefix for speaker ids, default empty"
+  echo "   --utt-prefix=<prefix>     # Prefix for utterance ids, default empty"
+  echo "   --spk-suffix=<suffix>     # Suffix for speaker ids, default empty"
+  echo "   --utt-suffix=<suffix>     # Suffix for utterance ids, default empty"
+  exit 1;
+fi
+
+
+export LC_ALL=C
+
+srcdir=$1
+destdir=$2
+
+if [ ! -f $srcdir/utt2spk ]; then
+  echo "copy_data_dir.sh: no such file $srcdir/utt2spk"
+  exit 1;
+fi
+
+if [ "$destdir" == "$srcdir" ]; then
+  echo "$0: this script requires <srcdir> and <destdir> to be different."
+  exit 1
+fi
+
+set -e;
+
+mkdir -p $destdir
+
+cat $srcdir/utt2spk | awk -v p=$utt_prefix -v s=$utt_suffix '{printf("%s %s%s%s\n", $1, p, $1, s);}' > $destdir/utt_map
+cat $srcdir/spk2utt | awk -v p=$spk_prefix -v s=$spk_suffix '{printf("%s %s%s%s\n", $1, p, $1, s);}' > $destdir/spk_map
+
+if [ ! -f $srcdir/utt2uniq ]; then
+  if [[ ! -z $utt_prefix  ||  ! -z $utt_suffix ]]; then
+    cat $srcdir/utt2spk | awk -v p=$utt_prefix -v s=$utt_suffix '{printf("%s%s%s %s\n", p, $1, s, $1);}' > $destdir/utt2uniq
+  fi
+else
+  cat $srcdir/utt2uniq | awk -v p=$utt_prefix -v s=$utt_suffix '{printf("%s%s%s %s\n", p, $1, s, $2);}' > $destdir/utt2uniq
+fi
+
+cat $srcdir/utt2spk | utils/apply_map.pl -f 1 $destdir/utt_map  | \
+  utils/apply_map.pl -f 2 $destdir/spk_map >$destdir/utt2spk
+
+utils/utt2spk_to_spk2utt.pl <$destdir/utt2spk >$destdir/spk2utt
+
+if [ -f $srcdir/feats.scp ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/feats.scp >$destdir/feats.scp
+fi
+
+if [ -f $srcdir/vad.scp ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/vad.scp >$destdir/vad.scp
+fi
+
+if [ -f $srcdir/utt2lang ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/utt2lang >$destdir/utt2lang
+fi
+
+if [ -f $srcdir/segments ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/segments >$destdir/segments
+  cp $srcdir/wav.scp $destdir
+else # no segments->wav indexed by utt.
+  if [ -f $srcdir/wav.scp ]; then
+    utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/wav.scp >$destdir/wav.scp
+  fi
+fi
+
+if [ -f $srcdir/reco2file_and_channel ]; then
+  cp $srcdir/reco2file_and_channel $destdir/
+fi
+
+if [ -f $srcdir/text ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/text >$destdir/text
+fi
+if [ -f $srcdir/utt2dur ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/utt2dur >$destdir/utt2dur
+fi
+if [ -f $srcdir/utt2num_frames ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/utt2num_frames >$destdir/utt2num_frames
+fi
+if [ -f $srcdir/reco2dur ]; then
+  if [ -f $srcdir/segments ]; then
+    cp $srcdir/reco2dur $destdir/reco2dur
+  else
+    utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/reco2dur >$destdir/reco2dur
+  fi
+fi
+if [ -f $srcdir/spk2gender ]; then
+  utils/apply_map.pl -f 1 $destdir/spk_map <$srcdir/spk2gender >$destdir/spk2gender
+fi
+if [ -f $srcdir/cmvn.scp ]; then
+  utils/apply_map.pl -f 1 $destdir/spk_map <$srcdir/cmvn.scp >$destdir/cmvn.scp
+fi
+for f in frame_shift stm glm ctm; do
+  if [ -f $srcdir/$f ]; then
+    cp $srcdir/$f $destdir
+  fi
+done
+
+rm $destdir/spk_map $destdir/utt_map
+
+echo "$0: copied data from $srcdir to $destdir"
+
+for f in feats.scp cmvn.scp vad.scp utt2lang utt2uniq utt2dur utt2num_frames text wav.scp reco2file_and_channel frame_shift stm glm ctm; do
+  if [ -f $destdir/$f ] && [ ! -f $srcdir/$f ]; then
+    echo "$0: file $f exists in dest $destdir but not in src $srcdir.  Moving it to"
+    echo " ... $destdir/.backup/$f"
+    mkdir -p $destdir/.backup
+    mv $destdir/$f $destdir/.backup/
+  fi
+done
+
+
+[ ! -f $srcdir/feats.scp ] && validate_opts="$validate_opts --no-feats"
+[ ! -f $srcdir/text ] && validate_opts="$validate_opts --no-text"
+
+utils/validate_data_dir.sh $validate_opts $destdir

UniAudio/UniAudio/egs/SE/utils/create_data_link.pl

@@ -0,0 +1,132 @@
+#!/usr/bin/env perl
+
+# Copyright 2013  Guoguo Chen
+#           2014  Johns Hopkins University (author: Daniel Povey)
+# Apache 2.0.
+#
+# This script distributes data onto different file systems by making symbolic
+# links. It is supposed to use together with utils/create_split_dir.pl, which
+# creates a "storage" directory that links to different file systems.
+#
+# If a sub-directory egs/storage does not exist, it does nothing. If it exists,
+# then it selects pseudo-randomly a number from those available in egs/storage/*
+# creates a link such as
+#
+#   egs/egs.3.4.ark -> storage/4/egs.3.4.ark
+#
+use strict;
+use warnings;
+use File::Basename;
+use File::Spec;
+use Getopt::Long;
+
+sub GetGCD {
+  my ($a, $b) = @_;
+  while ($a != $b) {
+    if ($a > $b) {
+      $a = $a - $b;
+    } else {
+      $b = $b - $a;
+    }
+  }
+  return $a;
+}
+
+my $Usage = <<EOU;
+create_data_link.pl:
+This script distributes data onto different file systems by making symbolic
+links. It is supposed to use together with utils/create_split_dir.pl, which
+creates a "storage" directory that links to different file systems.
+
+If a sub-directory foo/storage does not exist, it does nothing. If it exists,
+then it selects pseudo-randomly a number from those available in foo/storage/*
+creates a link such as
+
+  foo/egs.3.4.ark -> storage/4/egs.3.4.ark
+
+Usage: utils/create_data_link.pl <data-archive1> [<data-archive2> ... ]
+ e.g.: utils/create_data_link.pl foo/bar/egs.3.4.ark foo/bar/egs.3.5.ark
+ (note: the dirname, e.g. foo/bar/, must be the same in all cases).
+
+See also utils/remove_data_links.sh
+EOU
+
+GetOptions();
+
+if (@ARGV == 0) {
+  die $Usage;
+}
+
+my $example_fullpath = $ARGV[0];
+
+# Check if the storage has been created. If so, do nothing.
+my $dirname = dirname($example_fullpath);
+if (! -d "$dirname/storage") {
+  exit(0);
+}
+
+# Storage exists, create symbolic links in the next few steps.
+
+# First, get a list of the available storage directories, and check if they are
+# properly created.
+opendir(my $dh, "$dirname/storage/") || die "$0: Fail to open $dirname/storage/\n";
+my @storage_dirs = grep(/^[0-9]*$/, readdir($dh));
+closedir($dh);
+my $num_storage = scalar(@storage_dirs);
+for (my $x = 1; $x <= $num_storage; $x++) {
+  (-d "$dirname/storage/$x") || die "$0: $dirname/storage/$x does not exist\n";
+}
+
+# Second, get the coprime list.
+my @coprimes;
+for (my $n = 1; $n <= $num_storage; $n++) {
+  if (GetGCD($n, $num_storage) == 1) {
+    push(@coprimes, $n);
+  }
+}
+
+my $ret = 0;
+
+foreach my $fullpath (@ARGV) {
+  if ($dirname ne dirname($fullpath)) {
+    die "Mismatch in directory names of arguments: $example_fullpath versus $fullpath";
+  }
+
+  # Finally, work out the directory index where we should put the data to.
+  my $basename = basename($fullpath);
+  my $filename_numbers = $basename;
+  $filename_numbers =~ s/[^0-9]+/ /g;
+  my @filename_numbers = split(" ", $filename_numbers);
+  my $total = 0;
+  my $index = 0;
+  foreach my $x (@filename_numbers) {
+    if ($index >= scalar(@coprimes)) {
+      $index = 0;
+    }
+    $total += $x * $coprimes[$index];
+    $index++;
+  }
+  my $dir_index = $total % $num_storage + 1;
+
+  # Make the symbolic link.
+  if (-e $fullpath) {
+    unlink($fullpath);
+  }
+  if (symlink("storage/$dir_index/$basename", $fullpath) != 1) { # failure
+    $ret = 1;  # will exit with error status.
+  }
+}
+
+exit($ret);
+
+## testing:
+# rm -rf foo bar
+# mkdir -p bar/{1,2,3,4}
+# mkdir -p foo/storage
+# for x in 1 2 3 4; do ln -s ../../bar/$x foo/storage/$x; done
+# utils/create_data_link.pl utils/create_data_link.pl foo/1.3.ark  foo/2.3.ark
+# ls -l foo
+# total 0
+# lrwxrwxrwx 1 dpovey fax 17 Sep  2 17:41 1.3.ark -> storage/3/1.3.ark
+# lrwxrwxrwx 1 dpovey fax 17 Sep  2 17:41 2.3.ark -> storage/4/2.3.ark
+# drwxr-xr-x 2 dpovey fax 38 Sep  2 17:40 storage

UniAudio/UniAudio/egs/SE/utils/create_split_dir.pl

@@ -0,0 +1,92 @@
+#!/usr/bin/env perl
+
+# Copyright 2013  Guoguo Chen
+# Apache 2.0.
+#
+# This script creates storage directories on different file systems, and creates
+# symbolic links to those directories. For example, a command
+#
+#   utils/create_split_dir.pl /export/gpu-0{3,4,5}/egs/storage egs/storage
+#
+# will mkdir -p all of those directories, and will create links
+#
+#   egs/storage/1 -> /export/gpu-03/egs/storage
+#   egs/storage/2 -> /export/gpu-03/egs/storage
+#   ...
+#
+use strict;
+use warnings;
+use File::Spec;
+use Getopt::Long;
+
+my $Usage = <<EOU;
+create_split_dir.pl:
+This script creates storage directories on different file systems, and creates
+symbolic links to those directories.
+
+Usage: utils/create_split_dir.pl <actual_storage_dirs> <pseudo_storage_dir>
+ e.g.: utils/create_split_dir.pl /export/gpu-0{3,4,5}/egs/storage egs/storage
+
+Allowed options:
+  --suffix    : Common suffix to <actual_storage_dirs>    (string, default = "")
+
+See also create_data_link.pl, which is intended to work with the resulting
+directory structure, and remove_data_links.sh
+EOU
+
+my $suffix="";
+GetOptions('suffix=s' => \$suffix);
+
+if (@ARGV < 2) {
+  die $Usage;
+}
+
+my $ans = 1;
+
+my $dir = pop(@ARGV);
+system("mkdir -p $dir 2>/dev/null");
+
+my @all_actual_storage = ();
+foreach my $file (@ARGV) {
+  push @all_actual_storage, File::Spec->rel2abs($file . "/" . $suffix);
+}
+
+my $index = 1;
+foreach my $actual_storage (@all_actual_storage) {
+  my $pseudo_storage = "$dir/$index";
+
+  # If the symbolic link already exists, delete it.
+  if (-l $pseudo_storage) {
+    print STDERR "$0: link $pseudo_storage already exists, not overwriting.\n";
+    $index++;
+    next;
+  }
+
+  # Create the destination directory and make the link.
+  system("mkdir -p $actual_storage 2>/dev/null");
+  if ($? != 0) {
+    print STDERR "$0: error creating directory $actual_storage\n";
+    exit(1);
+  }
+  { # create a README file for easier deletion.
+    open(R, ">$actual_storage/README.txt");
+    my $storage_dir = File::Spec->rel2abs($dir);
+    print R "# This directory is linked from $storage_dir, as part of Kaldi striped data\n";
+    print R "# The full list of directories where this data resides is:\n";
+    foreach my $d (@all_actual_storage) {
+      print R "$d\n";
+    }
+    close(R);
+  }
+  my $ret = symlink($actual_storage, $pseudo_storage);
+
+  # Process the returned values
+  $ans = $ans && $ret;
+  if (! $ret) {
+    print STDERR "Error linking $actual_storage to $pseudo_storage\n";
+  }
+
+  $index++;
+}
+
+exit($ans == 1 ? 0 : 1);

UniAudio/UniAudio/egs/SE/utils/ctm/convert_ctm.pl

@@ -0,0 +1,96 @@
+#!/usr/bin/env perl
+
+# Copyright 2012  Johns Hopkins University (Author: Daniel Povey).  Apache 2.0.
+
+# This takes as standard input a ctm file that's "relative to the utterance",
+# i.e. times are measured relative to the beginning of the segments, and it
+# uses a "segments" file (format:
+# utterance-id recording-id start-time end-time
+# ) and a "reco2file_and_channel" file (format:
+# recording-id basename-of-file
+
+$skip_unknown=undef;
+if ( $ARGV[0] eq "--skip-unknown" ) {
+  $skip_unknown=1;
+  shift @ARGV;
+}
+
+if (@ARGV < 2 || @ARGV > 3) {
+  print STDERR "Usage: convert_ctm.pl <segments-file> <reco2file_and_channel-file> [<utterance-ctm>] > real-ctm\n";
+  exit(1);
+}
+
+$segments = shift @ARGV;
+$reco2file_and_channel = shift @ARGV;
+
+open(S, "<$segments") || die "opening segments file $segments";
+while(<S>) {
+  @A = split(" ", $_);
+  @A == 4 || die "Bad line in segments file: $_";
+  ($utt, $recording_id, $begin_time, $end_time) = @A;
+  $utt2reco{$utt} = $recording_id;
+  $begin{$utt} = $begin_time;
+  $end{$utt} = $end_time;
+}
+close(S);
+open(R, "<$reco2file_and_channel") || die "open reco2file_and_channel file $reco2file_and_channel";
+while(<R>) {
+  @A = split(" ", $_);
+  @A == 3 || die "Bad line in reco2file_and_channel file: $_";
+  ($recording_id, $file, $channel) = @A;
+  $reco2file{$recording_id} = $file;
+  $reco2channel{$recording_id} = $channel;
+}
+
+
+# Now process the ctm file, which is either the standard input or the third
+# command-line argument.
+$num_done = 0;
+while(<>) {
+  @A= split(" ", $_);
+  ( @A == 5 || @A == 6 ) || die "Unexpected ctm format: $_";
+  # lines look like:
+  # <utterance-id> 1 <begin-time> <length> <word> [ confidence ]
+  ($utt, $one, $wbegin, $wlen, $w, $conf) = @A;
+  $reco = $utt2reco{$utt};
+  if (!defined $reco) { 
+      next if defined $skip_unknown;
+      die "Utterance-id $utt not defined in segments file $segments"; 
+  }
+  $file = $reco2file{$reco};
+  $channel = $reco2channel{$reco};
+  if (!defined $file || !defined $channel) { 
+    die "Recording-id $reco not defined in reco2file_and_channel file $reco2file_and_channel"; 
+  }
+  $b = $begin{$utt};
+  $e = $end{$utt};
+  $wbegin_r = $wbegin + $b; # Make it relative to beginning of the recording.
+  $wbegin_r = sprintf("%.2f", $wbegin_r);
+  $wlen = sprintf("%.2f", $wlen);
+  if (defined $conf) {
+    $line = "$file $channel $wbegin_r $wlen $w $conf\n"; 
+  } else {
+    $line = "$file $channel $wbegin_r $wlen $w\n"; 
+  }
+  if ($wbegin_r + $wlen > $e + 0.01) {
+    print STDERR "Warning: word appears to be past end of recording; line is $line";
+  }
+  print $line; # goes to stdout.
+  $num_done++;
+}
+
+if ($num_done == 0) { exit 1; } else { exit 0; }
+
+__END__
+
+# Test example [also test it without the 0.5's]
+echo utt reco 10.0 20.0 > segments
+echo reco file A > reco2file_and_channel
+echo utt 1 8.0 1.0 word 0.5 > ctm_in
+echo file A 18.00 1.00 word 0.5 > ctm_out
+utils/convert_ctm.pl segments reco2file_and_channel ctm_in | cmp - ctm_out || echo error
+rm segments reco2file_and_channel ctm_in ctm_out
+
+
+
+

UniAudio/UniAudio/egs/SE/utils/ctm/fix_ctm.sh

@@ -0,0 +1,32 @@
+#! /bin/bash
+
+stmfile=$1
+ctmfile=$2
+
+segments_stm=`cat $stmfile | cut -f 1 -d ' ' | sort -u`
+segments_ctm=`cat $ctmfile | cut -f 1 -d ' ' | sort -u`
+
+segments_stm_count=`echo "$segments_stm" | wc -l `
+segments_ctm_count=`echo "$segments_ctm" | wc -l `
+
+#echo $segments_stm_count
+#echo $segments_ctm_count
+
+if [ "$segments_stm_count" -gt "$segments_ctm_count"  ] ; then
+  pp=$( diff <(echo "$segments_stm") <(echo "$segments_ctm" ) | grep "^<" | sed "s/^< *//g")
+  (
+    for elem in $pp ; do
+      echo "$elem 1 0 0 EMPTY_RECOGNIZED_PHRASE"
+    done
+  ) >> $ctmfile
+  echo "FIXED CTM FILE"
+  exit 0
+elif [ "$segments_stm_count" -lt "$segments_ctm_count"  ] ; then
+  echo "Segment STM count: $segments_stm_count"
+  echo "Segment CTM count: $segments_ctm_count"
+  echo "FAILURE FIXING CTM FILE"
+  exit 1
+else
+  exit 0
+fi
+

UniAudio/UniAudio/egs/SE/utils/ctm/resolve_ctm_overlaps.py

@@ -0,0 +1,324 @@
+#! /usr/bin/env python
+
+# Copyright 2014  Johns Hopkins University (Authors: Daniel Povey)
+#           2014  Vijayaditya Peddinti
+#           2016  Vimal Manohar
+# Apache 2.0.
+
+"""
+Script to combine ctms with overlapping segments.
+The current approach is very simple. It ignores the words,
+which are hypothesized in the half of the overlapped region
+that is closer to the utterance boundary.
+So if there are two segments
+in the region 0s to 30s and 25s to 55s, with overlap of 5s,
+the last 2.5s of the first utterance i.e. from 27.5s to 30s is truncated
+and the first 2.5s of the second utterance i.e. from 25s to 27.s is truncated.
+"""
+
+from __future__ import print_function
+from __future__ import division
+import argparse
+import collections
+import logging
+
+from collections import defaultdict
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+handler = logging.StreamHandler()
+handler.setLevel(logging.INFO)
+formatter = logging.Formatter(
+    '%(asctime)s [%(pathname)s:%(lineno)s - '
+    '%(funcName)s - %(levelname)s ] %(message)s')
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+
+def get_args():
+    """gets command line arguments"""
+
+    usage = """ Python script to resolve overlaps in ctms.  May be used with
+                utils/data/subsegment_data_dir.sh. """
+    parser = argparse.ArgumentParser(usage)
+    parser.add_argument('segments', type=argparse.FileType('r'),
+                        help='use segments to resolve overlaps')
+    parser.add_argument('ctm_in', type=argparse.FileType('r'),
+                        help='input_ctm_file')
+    parser.add_argument('ctm_out', type=argparse.FileType('w'),
+                        help='output_ctm_file')
+    parser.add_argument('--verbose', type=int, default=0,
+                        help="Higher value for more verbose logging.")
+    args = parser.parse_args()
+
+    if args.verbose > 2:
+        logger.setLevel(logging.DEBUG)
+        handler.setLevel(logging.DEBUG)
+
+    return args
+
+
+def read_segments(segments_file):
+    """Read from segments and returns two dictionaries,
+    {utterance-id: (recording_id, start_time, end_time)}
+    {recording_id: list-of-utterances}
+    """
+    segments = {}
+    reco2utt = defaultdict(list)
+
+    num_lines = 0
+    for line in segments_file:
+        num_lines += 1
+        parts = line.strip().split()
+        assert len(parts) in [4, 5]
+        segments[parts[0]] = (parts[1], float(parts[2]), float(parts[3]))
+        reco2utt[parts[1]].append(parts[0])
+
+    logger.info("Read %d lines from segments file %s",
+                num_lines, segments_file.name)
+    segments_file.close()
+
+    return segments, reco2utt
+
+
+def read_ctm(ctm_file, segments):
+    """Read CTM from ctm_file into a dictionary of values indexed by the
+    recording.
+    It is assumed to be sorted by the recording-id and utterance-id.
+
+    Returns a dictionary {recording : ctm_lines}
+        where ctm_lines is a list of lines of CTM corresponding to the
+        utterances in the recording.
+        The format is as follows:
+        [[(utteranceA, channelA, start_time1, duration1, hyp_word1, conf1),
+          (utteranceA, channelA, start_time2, duration2, hyp_word2, conf2),
+          ...
+          (utteranceA, channelA, start_timeN, durationN, hyp_wordN, confN)],
+         [(utteranceB, channelB, start_time1, duration1, hyp_word1, conf1),
+          (utteranceB, channelB, start_time2, duration2, hyp_word2, conf2),
+          ...],
+         ...
+         [...
+          (utteranceZ, channelZ, start_timeN, durationN, hyp_wordN, confN)]
+        ]
+    """
+    ctms = {}
+
+    num_lines = 0
+    for line in ctm_file:
+        num_lines += 1
+        parts = line.split()
+
+        utt = parts[0]
+        reco = segments[utt][0]
+
+        if (reco, utt) not in ctms:
+            ctms[(reco, utt)] = []
+
+        ctms[(reco, utt)].append([parts[0], parts[1], float(parts[2]),
+                                  float(parts[3])] + parts[4:])
+
+    logger.info("Read %d lines from CTM %s", num_lines, ctm_file.name)
+
+    ctm_file.close()
+    return ctms
+
+
+def resolve_overlaps(ctms, segments):
+    """Resolve overlaps within segments of the same recording.
+
+    Returns new lines of CTM for the recording.
+
+    Arguments:
+        ctms - The CTM lines for a single recording. This is one value stored
+            in the dictionary read by read_ctm(). Assumes that the lines
+            are sorted by the utterance-ids.
+            The format is the following:
+            [[(utteranceA, channelA, start_time1, duration1, hyp_word1, conf1),
+              (utteranceA, channelA, start_time2, duration2, hyp_word2, conf2),
+              ...
+              (utteranceA, channelA, start_timeN, durationN, hyp_wordN, confN)
+             ],
+             [(utteranceB, channelB, start_time1, duration1, hyp_word1, conf1),
+              (utteranceB, channelB, start_time2, duration2, hyp_word2, conf2),
+              ...],
+             ...
+             [...
+              (utteranceZ, channelZ, start_timeN, durationN, hyp_wordN, confN)]
+            ]
+        segments - Dictionary containing the output of read_segments()
+            { utterance_id: (recording_id, start_time, end_time) }
+        """
+    total_ctm = []
+    if len(ctms) == 0:
+        raise RuntimeError('CTMs for recording is empty. '
+                           'Something wrong with the input ctms')
+
+    # First column of first line in CTM for first utterance
+    next_utt = ctms[0][0][0]
+    for utt_index, ctm_for_cur_utt in enumerate(ctms):
+        if utt_index == len(ctms) - 1:
+            break
+
+        if len(ctm_for_cur_utt) == 0:
+            next_utt = ctms[utt_index + 1][0][0]
+            continue
+
+        cur_utt = ctm_for_cur_utt[0][0]
+        if cur_utt != next_utt:
+            logger.error(
+                "Current utterance %s is not the same as the next "
+                "utterance %s in previous iteration.\n"
+                "CTM is not sorted by utterance-id?",
+                cur_utt, next_utt)
+            raise ValueError
+
+        # Assumption here is that the segments are written in
+        # consecutive order?
+        ctm_for_next_utt = ctms[utt_index + 1]
+        next_utt = ctm_for_next_utt[0][0]
+        if segments[next_utt][1] < segments[cur_utt][1]:
+            logger.error(
+                "Next utterance %s <= Current utterance %s. "
+                "CTM is not sorted by start-time of utterance-id.",
+                next_utt, cur_utt)
+            raise ValueError
+
+        try:
+            # length of this utterance
+            window_length = segments[cur_utt][2] - segments[cur_utt][1]
+
+            # overlap of this segment with the next segment
+            # i.e. current_utterance_end_time - next_utterance_start_time
+            # Note: It is possible for this to be negative when there is
+            # actually no overlap between consecutive segments.
+            try:
+                overlap = segments[cur_utt][2] - segments[next_utt][1]
+            except KeyError:
+                logger("Could not find utterance %s in segments",
+                       next_utt)
+                raise
+
+            if overlap > 0 and segments[next_utt][2] <= segments[cur_utt][2]:
+                # Next utterance is entirely within this utterance.
+                # So we leave this ctm as is and make the next one empty.
+                total_ctm.extend(ctm_for_cur_utt)
+                ctms[utt_index + 1] = []
+                continue
+
+            # find a break point (a line in the CTM) for the current utterance
+            # i.e. the first line that has more than half of it outside
+            # the first half of the overlap region.
+            # Note: This line will not be included in the output CTM, which is
+            # only upto the line before this.
+            try:
+                index = next(
+                    (i for i, line in enumerate(ctm_for_cur_utt)
+                     if (line[2] + line[3] / 2.0
+                         > window_length - overlap / 2.0)))
+            except StopIteration:
+                # It is possible for such a word to not exist, e.g the last
+                # word in the CTM is longer than overlap length and starts
+                # before the beginning of the overlap.
+                # or the last word ends before the middle of the overlap.
+                index = len(ctm_for_cur_utt)
+
+            # Ignore the hypotheses beyond this midpoint. They will be
+            # considered as part of the next segment.
+            total_ctm.extend(ctm_for_cur_utt[:index])
+
+            # Find a break point (a line in the CTM) for the next utterance
+            # i.e. the first line that has more than half of it outside
+            # the first half of the overlap region.
+            try:
+                index = next(
+                    (i for i, line in enumerate(ctm_for_next_utt)
+                    if line[2] + line[3] / 2.0 > overlap / 2.0))
+            except StopIteration:
+                # This can happen if there is no word hypothesized after
+                # half the overlap region.
+                ctms[utt_index + 1] = []
+                continue
+
+            if index > 0:
+                # Update the ctm_for_next_utt to include only the lines
+                # starting from index.
+                ctms[utt_index + 1] = ctm_for_next_utt[index:]
+            # else leave the ctm as is.
+        except:
+            logger.error("Could not resolve overlaps between CTMs for "
+                         "%s and %s", cur_utt, next_utt)
+            logger.error("Current CTM:")
+            for line in ctm_for_cur_utt:
+                logger.error(ctm_line_to_string(line))
+            logger.error("Next CTM:")
+            for line in ctm_for_next_utt:
+                logger.error(ctm_line_to_string(line))
+            raise
+
+    # merge the last ctm entirely
+    total_ctm.extend(ctms[-1])
+
+    return total_ctm
+
+
+def ctm_line_to_string(line):
+    """Converts a line of CTM to string."""
+    return "{0} {1} {2} {3} {4}".format(line[0], line[1], line[2], line[3],
+                                        " ".join(line[4:]))
+
+
+def write_ctm(ctm_lines, out_file):
+    """Writes CTM lines stored in a list to file."""
+    for line in ctm_lines:
+        print(ctm_line_to_string(line), file=out_file)
+
+
+def run(args):
+    """this method does everything in this script"""
+    segments, reco2utt = read_segments(args.segments)
+    ctms = read_ctm(args.ctm_in, segments)
+
+    for reco, utts in reco2utt.items():
+        ctms_for_reco = []
+        for utt in sorted(utts, key=lambda x: segments[x][1]):
+            if (reco, utt) in ctms:
+                ctms_for_reco.append(ctms[(reco, utt)])
+        if len(ctms_for_reco) == 0:
+            logger.info("CTM for recording {0} was empty".format(reco))
+            continue
+        try:
+            # Process CTMs in the recordings
+            ctms_for_reco = resolve_overlaps(ctms_for_reco, segments)
+            write_ctm(ctms_for_reco, args.ctm_out)
+        except Exception:
+            logger.error("Failed to process CTM for recording %s",
+                         reco)
+            raise
+    args.ctm_out.close()
+    logger.info("Wrote CTM for %d recordings.", len(ctms))
+
+
+def main():
+    """The main function which parses arguments and call run()."""
+    args = get_args()
+    try:
+        run(args)
+    except:
+        logger.error("Failed to resolve overlaps", exc_info=True)
+        raise SystemExit(1)
+    finally:
+        try:
+            for f in [args.segments, args.ctm_in, args.ctm_out]:
+                if f is not None:
+                    f.close()
+        except IOError:
+            logger.error("Could not close some files. "
+                         "Disk error or broken pipes?")
+            raise
+        except UnboundLocalError:
+            raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

UniAudio/UniAudio/egs/SE/utils/data/combine_data.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+# Copyright 2012  Johns Hopkins University (Author: Daniel Povey).  Apache 2.0.
+#           2014  David Snyder
+
+# This script combines the data from multiple source directories into
+# a single destination directory.
+
+# See http://kaldi-asr.org/doc/data_prep.html#data_prep_data for information
+# about what these directories contain.
+
+# Begin configuration section.
+extra_files= # specify additional files in 'src-data-dir' to merge, ex. "file1 file2 ..."
+skip_fix=false # skip the fix_data_dir.sh in the end
+# End configuration section.
+
+echo "$0 $@"  # Print the command line for logging
+
+if [ -f path.sh ]; then . ./path.sh; fi
+. parse_options.sh || exit 1;
+
+if [ $# -lt 2 ]; then
+  echo "Usage: combine_data.sh [--extra-files 'file1 file2'] <dest-data-dir> <src-data-dir1> <src-data-dir2> ..."
+  echo "Note, files that don't appear in all source dirs will not be combined,"
+  echo "with the exception of utt2uniq and segments, which are created where necessary."
+  exit 1
+fi
+
+dest=$1;
+shift;
+
+first_src=$1;
+
+rm -r $dest 2>/dev/null || true
+mkdir -p $dest;
+
+export LC_ALL=C
+
+for dir in $*; do
+  if [ ! -f $dir/utt2spk ]; then
+    echo "$0: no such file $dir/utt2spk"
+    exit 1;
+  fi
+done
+
+# Check that frame_shift are compatible, where present together with features.
+dir_with_frame_shift=
+for dir in $*; do
+  if [[ -f $dir/feats.scp && -f $dir/frame_shift ]]; then
+    if [[ $dir_with_frame_shift ]] &&
+       ! cmp -s $dir_with_frame_shift/frame_shift $dir/frame_shift; then
+      echo "$0:error: different frame_shift in directories $dir and " \
+           "$dir_with_frame_shift. Cannot combine features."
+      exit 1;
+    fi
+    dir_with_frame_shift=$dir
+  fi
+done
+
+# W.r.t. utt2uniq file the script has different behavior compared to other files
+# it is not compulsary for it to exist in src directories, but if it exists in
+# even one it should exist in all. We will create the files where necessary
+has_utt2uniq=false
+for in_dir in $*; do
+  if [ -f $in_dir/utt2uniq ]; then
+    has_utt2uniq=true
+    break
+  fi
+done
+
+if $has_utt2uniq; then
+  # we are going to create an utt2uniq file in the destdir
+  for in_dir in $*; do
+    if [ ! -f $in_dir/utt2uniq ]; then
+      # we assume that utt2uniq is a one to one mapping
+      cat $in_dir/utt2spk | awk '{printf("%s %s\n", $1, $1);}'
+    else
+      cat $in_dir/utt2uniq
+    fi
+  done | sort -k1 > $dest/utt2uniq
+  echo "$0: combined utt2uniq"
+else
+  echo "$0 [info]: not combining utt2uniq as it does not exist"
+fi
+# some of the old scripts might provide utt2uniq as an extrafile, so just remove it
+extra_files=$(echo "$extra_files"|sed -e "s/utt2uniq//g")
+
+# segments are treated similarly to utt2uniq. If it exists in some, but not all
+# src directories, then we generate segments where necessary.
+has_segments=false
+for in_dir in $*; do
+  if [ -f $in_dir/segments ]; then
+    has_segments=true
+    break
+  fi
+done
+
+if $has_segments; then
+  for in_dir in $*; do
+    if [ ! -f $in_dir/segments ]; then
+      echo "$0 [info]: will generate missing segments for $in_dir" 1>&2
+      utils/data/get_segments_for_data.sh $in_dir
+    else
+      cat $in_dir/segments
+    fi
+  done | sort -k1 > $dest/segments
+  echo "$0: combined segments"
+else
+  echo "$0 [info]: not combining segments as it does not exist"
+fi
+
+for file in utt2spk utt2lang utt2dur utt2num_frames reco2dur feats.scp text cmvn.scp vad.scp reco2file_and_channel wav.scp spk2gender $extra_files; do
+  exists_somewhere=false
+  absent_somewhere=false
+  for d in $*; do
+    if [ -f $d/$file ]; then
+      exists_somewhere=true
+    else
+      absent_somewhere=true
+      fi
+  done
+
+  if ! $absent_somewhere; then
+    set -o pipefail
+    ( for f in $*; do cat $f/$file; done ) | sort -k1 > $dest/$file || exit 1;
+    set +o pipefail
+    echo "$0: combined $file"
+  else
+    if ! $exists_somewhere; then
+      echo "$0 [info]: not combining $file as it does not exist"
+    else
+      echo "$0 [info]: **not combining $file as it does not exist everywhere**"
+    fi
+  fi
+done
+
+utils/utt2spk_to_spk2utt.pl <$dest/utt2spk >$dest/spk2utt
+
+if [[ $dir_with_frame_shift ]]; then
+  cp $dir_with_frame_shift/frame_shift $dest
+fi
+
+if ! $skip_fix ; then
+  utils/fix_data_dir.sh $dest || exit 1;
+fi
+
+exit 0

UniAudio/UniAudio/egs/SE/utils/data/combine_short_segments.sh

@@ -0,0 +1,187 @@
+#!/usr/bin/env bash
+
+# Copyright 2013  Johns Hopkins University (author: Daniel Povey)
+# Apache 2.0
+
+# This script copies and modifies a data directory while combining
+# segments whose duration is lower than a specified minimum segment
+# length.
+#
+# Note: this does not work for the wav.scp, since there is no natural way to
+# concatenate segments; you have to operate on directories that already have
+# features extracted.
+
+#
+
+
+# begin configuration section
+cleanup=true
+speaker_only=false  # If true, utterances are only combined from the same speaker.
+                    # It may be useful for the speaker recognition task.
+                    # If false, utterances are preferentially combined from the same speaker,
+                    # and then combined across different speakers.
+# end configuration section
+
+
+. utils/parse_options.sh
+
+if [ $# != 3 ]; then
+  echo "Usage: "
+  echo "  $0 [options] <srcdir> <min-segment-length-in-seconds> <dir>"
+  echo "e.g.:"
+  echo " $0 data/train 1.55 data/train_comb"
+  echo " Options:"
+  echo "  --speaker-only <true|false>  # options to internal/choose_utts_to_combine.py, default false."
+  exit 1;
+fi
+
+
+export LC_ALL=C
+
+srcdir=$1
+min_seg_len=$2
+dir=$3
+
+if [ "$dir" == "$srcdir" ]; then
+  echo "$0: this script requires <srcdir> and <dir> to be different."
+  exit 1
+fi
+
+for f in $srcdir/utt2spk $srcdir/feats.scp; do
+  [ ! -s $f ] && echo "$0: expected file $f to exist and be nonempty" && exit 1
+done
+
+if ! awk '{if (NF != 2) exit(1);}' <$srcdir/feats.scp; then
+  echo "$0: could not combine short segments because $srcdir/feats.scp has "
+  echo " entries with too many fields"
+fi
+
+if ! mkdir -p $dir; then
+  echo "$0: could not create directory $dir"
+  exit 1;
+fi
+
+if ! utils/validate_data_dir.sh --no-text $srcdir; then
+  echo "$0: failed to validate input directory $srcdir.  If needed, run   utils/fix_data_dir.sh $srcdir"
+  exit 1
+fi
+
+if ! python -c "x=float('$min_seg_len'); assert(x>0.0 and x<100.0);" 2>/dev/null; then
+  echo "$0: bad <min-segment-length-in-seconds>: got '$min_seg_len'"
+  exit 1
+fi
+
+set -e
+set -o pipefail
+
+# make sure $srcdir/utt2dur exists.
+utils/data/get_utt2dur.sh $srcdir
+
+utils/data/internal/choose_utts_to_combine.py --min-duration=$min_seg_len \
+  --merge-within-speakers-only=$speaker_only \
+  $srcdir/spk2utt $srcdir/utt2dur $dir/utt2utts $dir/utt2spk $dir/utt2dur
+
+utils/utt2spk_to_spk2utt.pl < $dir/utt2spk > $dir/spk2utt
+
+# create the feats.scp.
+# if a line of utt2utts is like 'utt2-comb2 utt2 utt3', then
+# the utils/apply_map.pl will create a line that looks like
+# 'utt2-comb2 foo.ark:4315 foo.ark:431423'
+# and the awk command creates suitable command lines like:
+# 'utt2-comb2 concat-feats foo.ark:4315 foo.ark:431423 - |'
+utils/apply_map.pl -f 2- $srcdir/feats.scp <$dir/utt2utts | \
+  awk '{if (NF<=2){print;} else { $1 = $1 " concat-feats --print-args=false"; $NF = $NF " - |"; print; }}' > $dir/feats.scp
+
+# create $dir/text by concatenating the source 'text' entries for the original
+# utts.
+if [ -f $srcdir/text ]; then
+  utils/apply_map.pl -f 2- $srcdir/text <$dir/utt2utts > $dir/text
+fi
+
+if [ -f $srcdir/utt2uniq ]; then
+  # the utt2uniq file is such that if 2 utts were derived from the same original
+  # utt (e.g. by speed perturbing) they map to the same 'uniq' value.  This is
+  # so that we can properly hold out validation data for neural net training and
+  # know that we're not training on perturbed verions of that utterance.  We
+  # need to obtain the utt2uniq file so that if any 2 'new' utts contain any of
+  # the same 'old' utts, their 'uniq' values are the same [but otherwise as far
+  # as possible, the 'uniq' values are different.]
+  #
+  # we'll do this by arranging the old 'uniq' values into groups as necessary to
+  # capture this property.
+
+  # The following command creates 'uniq_sets', each line of which contains
+  # a set of original 'uniq' values, and effectively we assert that they must
+  # be grouped together to the same 'uniq' value.
+  # the first awk command prints a group of the original utterance-ids that
+  # are combined together into a single new utterance, and the apply_map
+  # command converts those into a list of original 'uniq' values.
+  awk '{$1 = ""; print;}' < $dir/utt2utts | \
+    utils/apply_map.pl $srcdir/utt2uniq > $dir/uniq_sets
+
+  # The next command creates $dir/uniq2merged_uniq, which is a map from the
+  # original 'uniq' values to the 'merged' uniq values.
+  # for example, if $dir/uniq_sets were to contain
+  # a b
+  # b c
+  # d
+  # then we'd obtain a uniq2merged_uniq file that looks like:
+  # a a
+  # b a
+  # c a
+  # d d
+  # ... because a and b appear together, and b and c appear together,
+  # they have to be merged into the same set, and we name that set 'a'
+  # (in general, we take the lowest string in lexicographical order).
+
+  cat $dir/uniq_sets | LC_ALL=C python3 -c '
+import sys;
+from collections import defaultdict
+uniq2orig_uniq = dict()
+equal_pairs = set()  # set of 2-tuples (a,b) which should have equal orig_uniq
+while True:
+    line = sys.stdin.readline()
+    if line == "": break
+    split_line = line.split() # list of uniq strings that should map in same set
+    # initialize uniq2orig_uniq to the identity mapping
+    for uniq in split_line: uniq2orig_uniq[uniq] = uniq
+    for a in split_line[1:]: equal_pairs.add((split_line[0], a))
+
+changed = True
+while changed:
+    changed = False
+    for a,b in equal_pairs:
+         min_orig_uniq = min(uniq2orig_uniq[a], uniq2orig_uniq[b])
+         for x in [a,b]:
+             if uniq2orig_uniq[x] != min_orig_uniq:
+                 uniq2orig_uniq[x] = min_orig_uniq
+                 changed = True
+
+for uniq in sorted(uniq2orig_uniq.keys()):
+    print(uniq, uniq2orig_uniq[uniq])
+' > $dir/uniq_to_orig_uniq
+  rm $dir/uniq_sets
+
+
+  # In the following command, suppose we have a line like:
+  # utt1-comb2 utt1 utt2
+  # .. the first awk command retains only the first original utt, to give
+  # utt1-comb2 utt1
+  # [we can pick one arbitrarily since we know any of them would map to the same
+  # orig_uniq value.]
+  # the first apply_map.pl command maps the 'utt1' to the 'uniq' value it mapped to
+  # in $srcdir, and the second apply_map.pl command maps it to the grouped 'uniq'
+  # value obtained by the inline python script above.
+  awk '{print $1, $2}' < $dir/utt2utts | utils/apply_map.pl -f 2 $srcdir/utt2uniq | \
+    utils/apply_map.pl -f 2 $dir/uniq_to_orig_uniq > $dir/utt2uniq
+  rm $dir/uniq_to_orig_uniq
+fi
+
+# note: the user will have to recompute the cmvn, as the speakers may have changed.
+rm $dir/cmvn.scp 2>/dev/null || true
+
+utils/validate_data_dir.sh --no-text --no-wav $dir
+
+if $cleanup; then
+  rm $dir/utt2utts
+fi

UniAudio/UniAudio/egs/SE/utils/data/convert_data_dir_to_whole.sh

@@ -0,0 +1,62 @@
+#! /bin/bash
+
+# Copyright 2016-2018  Vimal Manohar
+# Apache 2.0
+
+# This scripts converts a data directory into a "whole" data directory
+# by removing the segments and using the recordings themselves as 
+# utterances
+
+set -o pipefail
+
+. ./path.sh
+
+. utils/parse_options.sh
+
+if [ $# -ne 2 ]; then
+  echo "Usage: convert_data_dir_to_whole.sh <in-data> <out-data>"
+  echo " e.g.: convert_data_dir_to_whole.sh data/dev data/dev_whole"
+  exit 1
+fi
+
+data=$1
+dir=$2
+
+if [ ! -f $data/segments ]; then
+  echo "$0: Data directory already does not contain segments. So just copying it."
+  utils/copy_data_dir.sh $data $dir
+  exit 0
+fi
+
+mkdir -p $dir
+cp $data/wav.scp $dir
+if [ -f $data/reco2file_and_channel ]; then 
+  cp $data/reco2file_and_channel $dir; 
+fi
+
+mkdir -p $dir/.backup
+if [ -f $dir/feats.scp ]; then
+  mv $dir/feats.scp $dir/.backup
+fi
+if [ -f $dir/cmvn.scp ]; then
+  mv $dir/cmvn.scp $dir/.backup
+fi
+if [ -f $dir/utt2spk ]; then
+  mv $dir/utt2spk $dir/.backup
+fi
+
+[ -f $data/stm ] && cp $data/stm $dir
+[ -f $data/glm ] && cp $data/glm $dir
+
+utils/data/internal/combine_segments_to_recording.py \
+  --write-reco2utt=$dir/reco2sorted_utts $data/segments $dir/utt2spk || exit 1
+
+if [ -f $data/text ]; then
+  utils/apply_map.pl -f 2- $data/text < $dir/reco2sorted_utts > $dir/text || exit 1
+fi
+
+rm $dir/reco2sorted_utts
+
+utils/fix_data_dir.sh $dir || exit 1
+
+exit 0

UniAudio/UniAudio/egs/SE/utils/data/copy_data_dir.sh

@@ -0,0 +1,149 @@
+#!/usr/bin/env bash
+
+# Copyright 2013  Johns Hopkins University (author: Daniel Povey)
+# Apache 2.0
+
+# This script operates on a directory, such as in data/train/,
+# that contains some subset of the following files:
+#  feats.scp
+#  wav.scp
+#  vad.scp
+#  spk2utt
+#  utt2spk
+#  text
+#
+# It copies to another directory, possibly adding a specified prefix or a suffix
+# to the utterance and/or speaker names.  Note, the recording-ids stay the same.
+#
+
+
+# begin configuration section
+spk_prefix=
+utt_prefix=
+spk_suffix=
+utt_suffix=
+validate_opts=   # should rarely be needed.
+# end configuration section
+
+. utils/parse_options.sh
+
+if [ $# != 2 ]; then
+  echo "Usage: "
+  echo "  $0 [options] <srcdir> <destdir>"
+  echo "e.g.:"
+  echo " $0 --spk-prefix=1- --utt-prefix=1- data/train data/train_1"
+  echo "Options"
+  echo "   --spk-prefix=<prefix>     # Prefix for speaker ids, default empty"
+  echo "   --utt-prefix=<prefix>     # Prefix for utterance ids, default empty"
+  echo "   --spk-suffix=<suffix>     # Suffix for speaker ids, default empty"
+  echo "   --utt-suffix=<suffix>     # Suffix for utterance ids, default empty"
+  exit 1;
+fi
+
+
+export LC_ALL=C
+
+srcdir=$1
+destdir=$2
+
+if [ ! -f $srcdir/utt2spk ]; then
+  echo "copy_data_dir.sh: no such file $srcdir/utt2spk"
+  exit 1;
+fi
+
+if [ "$destdir" == "$srcdir" ]; then
+  echo "$0: this script requires <srcdir> and <destdir> to be different."
+  exit 1
+fi
+
+set -e;
+
+mkdir -p $destdir
+
+cat $srcdir/utt2spk | awk -v p=$utt_prefix -v s=$utt_suffix '{printf("%s %s%s%s\n", $1, p, $1, s);}' > $destdir/utt_map
+cat $srcdir/spk2utt | awk -v p=$spk_prefix -v s=$spk_suffix '{printf("%s %s%s%s\n", $1, p, $1, s);}' > $destdir/spk_map
+
+if [ ! -f $srcdir/utt2uniq ]; then
+  if [[ ! -z $utt_prefix  ||  ! -z $utt_suffix ]]; then
+    cat $srcdir/utt2spk | awk -v p=$utt_prefix -v s=$utt_suffix '{printf("%s%s%s %s\n", p, $1, s, $1);}' > $destdir/utt2uniq
+  fi
+else
+  cat $srcdir/utt2uniq | awk -v p=$utt_prefix -v s=$utt_suffix '{printf("%s%s%s %s\n", p, $1, s, $2);}' > $destdir/utt2uniq
+fi
+
+cat $srcdir/utt2spk | utils/apply_map.pl -f 1 $destdir/utt_map  | \
+  utils/apply_map.pl -f 2 $destdir/spk_map >$destdir/utt2spk
+
+utils/utt2spk_to_spk2utt.pl <$destdir/utt2spk >$destdir/spk2utt
+
+if [ -f $srcdir/feats.scp ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/feats.scp >$destdir/feats.scp
+fi
+
+if [ -f $srcdir/vad.scp ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/vad.scp >$destdir/vad.scp
+fi
+
+if [ -f $srcdir/utt2lang ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/utt2lang >$destdir/utt2lang
+fi
+
+if [ -f $srcdir/segments ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/segments >$destdir/segments
+  cp $srcdir/wav.scp $destdir
+else # no segments->wav indexed by utt.
+  if [ -f $srcdir/wav.scp ]; then
+    utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/wav.scp >$destdir/wav.scp
+  fi
+fi
+
+if [ -f $srcdir/reco2file_and_channel ]; then
+  cp $srcdir/reco2file_and_channel $destdir/
+fi
+
+if [ -f $srcdir/text ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/text >$destdir/text
+fi
+if [ -f $srcdir/utt2dur ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/utt2dur >$destdir/utt2dur
+fi
+if [ -f $srcdir/utt2num_frames ]; then
+  utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/utt2num_frames >$destdir/utt2num_frames
+fi
+if [ -f $srcdir/reco2dur ]; then
+  if [ -f $srcdir/segments ]; then
+    cp $srcdir/reco2dur $destdir/reco2dur
+  else
+    utils/apply_map.pl -f 1 $destdir/utt_map <$srcdir/reco2dur >$destdir/reco2dur
+  fi
+fi
+if [ -f $srcdir/spk2gender ]; then
+  utils/apply_map.pl -f 1 $destdir/spk_map <$srcdir/spk2gender >$destdir/spk2gender
+fi
+if [ -f $srcdir/cmvn.scp ]; then
+  utils/apply_map.pl -f 1 $destdir/spk_map <$srcdir/cmvn.scp >$destdir/cmvn.scp
+fi
+for f in frame_shift stm glm ctm; do
+  if [ -f $srcdir/$f ]; then
+    cp $srcdir/$f $destdir
+  fi
+done
+
+rm $destdir/spk_map $destdir/utt_map
+
+echo "$0: copied data from $srcdir to $destdir"
+
+for f in feats.scp cmvn.scp vad.scp utt2lang utt2uniq utt2dur utt2num_frames text wav.scp reco2file_and_channel frame_shift stm glm ctm; do
+  if [ -f $destdir/$f ] && [ ! -f $srcdir/$f ]; then
+    echo "$0: file $f exists in dest $destdir but not in src $srcdir.  Moving it to"
+    echo " ... $destdir/.backup/$f"
+    mkdir -p $destdir/.backup
+    mv $destdir/$f $destdir/.backup/
+  fi
+done
+
+
+[ ! -f $srcdir/feats.scp ] && validate_opts="$validate_opts --no-feats"
+[ ! -f $srcdir/text ] && validate_opts="$validate_opts --no-text"
+
+utils/validate_data_dir.sh $validate_opts $destdir

UniAudio/UniAudio/egs/SE/utils/data/extend_segment_times.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+
+from __future__ import print_function
+import sys
+import argparse
+from collections import defaultdict
+
+
+parser = argparse.ArgumentParser(description="""
+ Usage: extend_segment_times.py [options] <input-segments >output-segments
+ This program pads the times in a 'segments' file (e.g. data/train/segments)
+ with specified left and right context (for cases where there was no
+ silence padding in the original segments file)""")
+
+parser.add_argument("--start-padding", type = float, default = 0.1,
+                    help="Amount of padding, in seconds, for the start time of "
+                    "each segment (start times <0 will be set to zero).")
+parser.add_argument("--end-padding", type = float, default = 0.1,
+                    help="Amount of padding, in seconds, for the end time of "
+                    "each segment.")
+parser.add_argument("--last-segment-end-padding", type = float, default = 0.1,
+                    help="Amount of padding, in seconds, for the end time of "
+                    "the last segment of each file (maximum allowed).")
+parser.add_argument("--fix-overlapping-segments", type = str,
+                    default = 'true', choices=['true', 'false'],
+                    help="If true, prevent segments from overlapping as a result "
+                    "of the padding (or that were already overlapping)")
+args = parser.parse_args()
+
+
+# the input file will be a sequence of lines which are each of the form:
+# <utterance-id> <recording-id> <start-time> <end-time>
+# e.g.
+# utt-1 recording-1 0.62 5.40
+# The output will be in the same format and in the same
+# order, except wiht modified times.
+
+# This variable maps from a recording-id to a listof the utterance
+# indexes (as integer indexes into 'entries']
+# that are part of that recording.
+recording_to_utt_indexes = defaultdict(list)
+
+# This is an array of the entries in the segments file, in the fomrat:
+# (utterance-id as astring, recording-id as string,
+#  start-time as float, end-time as float)
+entries = []
+
+
+while True:
+    line = sys.stdin.readline()
+    if line == '':
+        break
+    try:
+        [ utt_id, recording_id, start_time, end_time ] = line.split()
+        start_time = float(start_time)
+        end_time = float(end_time)
+    except:
+        sys.exit("extend_segment_times.py: could not interpret line: " + line)
+    if not end_time > start_time:
+        print("extend_segment_times.py: bad segment (ignoring): " + line,
+              file = sys.stderr)
+    recording_to_utt_indexes[recording_id].append(len(entries))
+    entries.append([utt_id, recording_id, start_time, end_time])
+
+num_times_fixed = 0
+
+for recording, utt_indexes in recording_to_utt_indexes.items():
+    # this_entries is a list of lists, sorted on mid-time.
+    # Notice: because lists are objects, when we change 'this_entries'
+    # we change the underlying entries.
+    this_entries = sorted([ entries[x] for x in utt_indexes ],
+                          key = lambda x : 0.5 * (x[2] + x[3]))
+    min_time = 0
+    max_time = max([ x[3] for x in this_entries ]) + args.last_segment_end_padding
+    start_padding = args.start_padding
+    end_padding = args.end_padding
+    for n in range(len(this_entries)):
+        this_entries[n][2] = max(min_time, this_entries[n][2] - start_padding)
+        this_entries[n][3] = min(max_time, this_entries[n][3] + end_padding)
+
+    for n in range(len(this_entries) - 1):
+        this_end_time = this_entries[n][3]
+        next_start_time = this_entries[n+1][2]
+        if this_end_time > next_start_time and args.fix_overlapping_segments == 'true':
+            midpoint = 0.5 * (this_end_time + next_start_time)
+            this_entries[n][3] = midpoint
+            this_entries[n+1][2] = midpoint
+            num_times_fixed += 1
+
+
+# this prints a number with a certain number of digits after
+# the point, while removing trailing zeros.
+def FloatToString(f):
+    num_digits = 6 # we want to print 6 digits after the zero
+    g = f
+    while abs(g) > 1.0:
+        g *= 0.1
+        num_digits += 1
+    format_str = '%.{0}g'.format(num_digits)
+    return format_str % f
+
+for entry in entries:
+    [ utt_id, recording_id, start_time, end_time ] = entry
+    if not start_time < end_time:
+        print("extend_segment_times.py: bad segment after processing (ignoring): " +
+              ' '.join(entry), file = sys.stderr)
+        continue
+    print(utt_id, recording_id, FloatToString(start_time), FloatToString(end_time))
+
+
+print("extend_segment_times.py: extended {0} segments; fixed {1} "
+      "overlapping segments".format(len(entries), num_times_fixed),
+      file = sys.stderr)
+
+## test:
+#  (echo utt1 reco1 0.2 6.2; echo utt2 reco1 6.3 9.8 )| extend_segment_times.py
+# and also try the above with the options --last-segment-end-padding=0.0 --fix-overlapping-segments=false
+

UniAudio/UniAudio/egs/SE/utils/data/extract_wav_segments_data_dir.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+
+# Copyright    2017  Hossein Hadian
+# Apache 2.0
+
+# This script copies a data directory (which has a 'segments' file), extracting
+# wav segments (according to the 'segments' file)
+# so that the resulting data directory does not have a 'segments' file anymore.
+
+nj=4
+cmd=run.pl
+
+. ./utils/parse_options.sh
+. ./path.sh
+
+if [ $# != 2 ]; then
+  echo "Usage: $0 <srcdir> <destdir>"
+  echo " This script copies data directory <srcdir> to <destdir> and removes"
+  echo " the 'segments' file by extracting the wav segments."
+  echo "Options: "
+  echo "  --nj <nj>                                        # number of parallel jobs"
+  echo "  --cmd (utils/run.pl|utils/queue.pl <queue opts>) # how to run jobs."
+  exit 1;
+fi
+
+
+export LC_ALL=C
+
+srcdir=$1
+dir=$2
+logdir=$dir/log
+
+if ! mkdir -p $dir/data; then
+  echo "$0: failed to create directory $dir/data"
+  exit 1
+fi
+mkdir -p $logdir
+
+set -eu -o pipefail
+utils/copy_data_dir.sh $srcdir $dir
+
+split_segments=""
+for n in $(seq $nj); do
+  split_segments="$split_segments $logdir/segments.$n"
+done
+
+utils/split_scp.pl $srcdir/segments $split_segments
+
+$cmd JOB=1:$nj $logdir/extract_wav_segments.JOB.log \
+     extract-segments scp,p:$srcdir/wav.scp $logdir/segments.JOB \
+     ark,scp:$dir/data/wav_segments.JOB.ark,$dir/data/wav_segments.JOB.scp
+
+# concatenate the .scp files together.
+for n in $(seq $nj); do
+  cat $dir/data/wav_segments.$n.scp
+done > $dir/data/wav_segments.scp
+
+cat $dir/data/wav_segments.scp | awk '{ print $1 " wav-copy " $2 " - |" }' >$dir/wav.scp
+rm $dir/{segments,reco2file_and_channel} 2>/dev/null || true

UniAudio/UniAudio/egs/SE/utils/data/fix_data_dir.sh

@@ -0,0 +1,215 @@
+#!/usr/bin/env bash
+
+# This script makes sure that only the segments present in
+# all of "feats.scp", "wav.scp" [if present], segments [if present]
+# text, and utt2spk are present in any of them.
+# It puts the original contents of data-dir into
+# data-dir/.backup
+
+cmd="$@"
+
+utt_extra_files=
+spk_extra_files=
+
+. utils/parse_options.sh
+
+if [ $# != 1 ]; then
+  echo "Usage: utils/data/fix_data_dir.sh <data-dir>"
+  echo "e.g.: utils/data/fix_data_dir.sh data/train"
+  echo "This script helps ensure that the various files in a data directory"
+  echo "are correctly sorted and filtered, for example removing utterances"
+  echo "that have no features (if feats.scp is present)"
+  exit 1
+fi
+
+data=$1
+
+if [ -f $data/images.scp ]; then
+  image/fix_data_dir.sh $cmd
+  exit $?
+fi
+
+mkdir -p $data/.backup
+
+[ ! -d $data ] && echo "$0: no such directory $data" && exit 1;
+
+[ ! -f $data/utt2spk ] && echo "$0: no such file $data/utt2spk" && exit 1;
+
+set -e -o pipefail -u
+
+tmpdir=$(mktemp -d /tmp/kaldi.XXXX);
+trap 'rm -rf "$tmpdir"' EXIT HUP INT PIPE TERM
+
+export LC_ALL=C
+
+function check_sorted {
+  file=$1
+  sort -k1,1 -u <$file >$file.tmp
+  if ! cmp -s $file $file.tmp; then
+    echo "$0: file $1 is not in sorted order or not unique, sorting it"
+    mv $file.tmp $file
+  else
+    rm $file.tmp
+  fi
+}
+
+for x in utt2spk spk2utt feats.scp text segments wav.scp cmvn.scp vad.scp \
+    reco2file_and_channel spk2gender utt2lang utt2uniq utt2dur reco2dur utt2num_frames; do
+  if [ -f $data/$x ]; then
+    cp $data/$x $data/.backup/$x
+    check_sorted $data/$x
+  fi
+done
+
+
+function filter_file {
+  filter=$1
+  file_to_filter=$2
+  cp $file_to_filter ${file_to_filter}.tmp
+  utils/filter_scp.pl $filter ${file_to_filter}.tmp > $file_to_filter
+  if ! cmp ${file_to_filter}.tmp  $file_to_filter >&/dev/null; then
+    length1=$(cat ${file_to_filter}.tmp | wc -l)
+    length2=$(cat ${file_to_filter} | wc -l)
+    if [ $length1 -ne $length2 ]; then
+      echo "$0: filtered $file_to_filter from $length1 to $length2 lines based on filter $filter."
+    fi
+  fi
+  rm $file_to_filter.tmp
+}
+
+function filter_recordings {
+  # We call this once before the stage when we filter on utterance-id, and once
+  # after.
+
+  if [ -f $data/segments ]; then
+  # We have a segments file -> we need to filter this and the file wav.scp, and
+  # reco2file_and_utt, if it exists, to make sure they have the same list of
+  # recording-ids.
+
+    if [ ! -f $data/wav.scp ]; then
+      echo "$0: $data/segments exists but not $data/wav.scp"
+      exit 1;
+    fi
+    awk '{print $2}' < $data/segments | sort | uniq > $tmpdir/recordings
+    n1=$(cat $tmpdir/recordings | wc -l)
+    [ ! -s $tmpdir/recordings ] && \
+      echo "Empty list of recordings (bad file $data/segments)?" && exit 1;
+    utils/filter_scp.pl $data/wav.scp $tmpdir/recordings > $tmpdir/recordings.tmp
+    mv $tmpdir/recordings.tmp $tmpdir/recordings
+
+
+    cp $data/segments{,.tmp}; awk '{print $2, $1, $3, $4}' <$data/segments.tmp >$data/segments
+    filter_file $tmpdir/recordings $data/segments
+    cp $data/segments{,.tmp}; awk '{print $2, $1, $3, $4}' <$data/segments.tmp >$data/segments
+    rm $data/segments.tmp
+
+    filter_file $tmpdir/recordings $data/wav.scp
+    [ -f $data/reco2file_and_channel ] && filter_file $tmpdir/recordings $data/reco2file_and_channel
+    [ -f $data/reco2dur ] && filter_file $tmpdir/recordings $data/reco2dur
+    true
+  fi
+}
+
+function filter_speakers {
+  # throughout this program, we regard utt2spk as primary and spk2utt as derived, so...
+  utils/utt2spk_to_spk2utt.pl $data/utt2spk > $data/spk2utt
+
+  cat $data/spk2utt | awk '{print $1}' > $tmpdir/speakers
+  for s in cmvn.scp spk2gender; do
+    f=$data/$s
+    if [ -f $f ]; then
+      filter_file $f $tmpdir/speakers
+    fi
+  done
+
+  filter_file $tmpdir/speakers $data/spk2utt
+  utils/spk2utt_to_utt2spk.pl $data/spk2utt > $data/utt2spk
+
+  for s in cmvn.scp spk2gender $spk_extra_files; do
+    f=$data/$s
+    if [ -f $f ]; then
+      filter_file $tmpdir/speakers $f
+    fi
+  done
+}
+
+function filter_utts {
+  cat $data/utt2spk | awk '{print $1}' > $tmpdir/utts
+
+  ! cat $data/utt2spk | sort | cmp - $data/utt2spk && \
+    echo "utt2spk is not in sorted order (fix this yourself)" && exit 1;
+
+  ! cat $data/utt2spk | sort -k2 | cmp - $data/utt2spk && \
+    echo "utt2spk is not in sorted order when sorted first on speaker-id " && \
+    echo "(fix this by making speaker-ids prefixes of utt-ids)" && exit 1;
+
+  ! cat $data/spk2utt | sort | cmp - $data/spk2utt && \
+    echo "spk2utt is not in sorted order (fix this yourself)" && exit 1;
+
+  if [ -f $data/utt2uniq ]; then
+    ! cat $data/utt2uniq | sort | cmp - $data/utt2uniq && \
+      echo "utt2uniq is not in sorted order (fix this yourself)" && exit 1;
+  fi
+
+  maybe_wav=
+  maybe_reco2dur=
+  [ ! -f $data/segments ] && maybe_wav=wav.scp # wav indexed by utts only if segments does not exist.
+  [ -s $data/reco2dur ] && [ ! -f $data/segments ] && maybe_reco2dur=reco2dur # reco2dur indexed by utts
+
+  maybe_utt2dur=
+  if [ -f $data/utt2dur ]; then
+    cat $data/utt2dur | \
+      awk '{ if (NF == 2 && $2 > 0) { print }}' > $data/utt2dur.ok || exit 1
+    maybe_utt2dur=utt2dur.ok
+  fi
+
+  maybe_utt2num_frames=
+  if [ -f $data/utt2num_frames ]; then
+    cat $data/utt2num_frames | \
+      awk '{ if (NF == 2 && $2 > 0) { print }}' > $data/utt2num_frames.ok || exit 1
+    maybe_utt2num_frames=utt2num_frames.ok
+  fi
+
+  for x in feats.scp text segments utt2lang $maybe_wav $maybe_utt2dur $maybe_utt2num_frames; do
+    if [ -f $data/$x ]; then
+      utils/filter_scp.pl $data/$x $tmpdir/utts > $tmpdir/utts.tmp
+      mv $tmpdir/utts.tmp $tmpdir/utts
+    fi
+  done
+  rm $data/utt2dur.ok 2>/dev/null || true
+  rm $data/utt2num_frames.ok 2>/dev/null || true
+
+  [ ! -s $tmpdir/utts ] && echo "fix_data_dir.sh: no utterances remained: not proceeding further." && \
+    rm $tmpdir/utts && exit 1;
+
+
+  if [ -f $data/utt2spk ]; then
+    new_nutts=$(cat $tmpdir/utts | wc -l)
+    old_nutts=$(cat $data/utt2spk | wc -l)
+    if [ $new_nutts -ne $old_nutts ]; then
+      echo "fix_data_dir.sh: kept $new_nutts utterances out of $old_nutts"
+    else
+      echo "fix_data_dir.sh: kept all $old_nutts utterances."
+    fi
+  fi
+
+  for x in utt2spk utt2uniq feats.scp vad.scp text segments utt2lang utt2dur utt2num_frames $maybe_wav $maybe_reco2dur $utt_extra_files; do
+    if [ -f $data/$x ]; then
+      cp $data/$x $data/.backup/$x
+      if ! cmp -s $data/$x <( utils/filter_scp.pl $tmpdir/utts $data/$x ) ; then
+        utils/filter_scp.pl $tmpdir/utts $data/.backup/$x > $data/$x
+      fi
+    fi
+  done
+
+}
+
+filter_recordings
+filter_speakers
+filter_utts
+filter_speakers
+filter_recordings
+
+utils/utt2spk_to_spk2utt.pl $data/utt2spk > $data/spk2utt
+
+echo "fix_data_dir.sh: old files are kept in $data/.backup"

UniAudio/UniAudio/egs/SE/utils/data/fix_subsegment_feats.pl

@@ -0,0 +1,106 @@
+#!/usr/bin/env perl
+
+# Copyright 2016  Vimal Manohar
+# Apache 2.0.
+
+use warnings;
+
+# This script reads from stdin a feats.scp file that contains frame ranges and
+# ensures that they don't exceed the maximum number of frames supplied in the
+# <utt2max-frames> file. 
+# <utt2max-frames> is usually computed using get_utt2num_frames.sh on the 
+# original directory which will be segmented using 
+# utils/data/subsegment_data_dir.sh.
+# 
+# e.g. feats.scp
+# utt_foo-1 foo-bar.ark:514231[721:892]
+# 
+# utt2max-frames
+# utt_foo-1 891
+# 
+# fixed_feats.scp
+# utt_foo-1 foo-bar.ark:514231[721:890]
+# 
+# Note: Here 891 is the number of frames in the archive foo-bar.ark
+# The frame end for utt_foo-1, i.e. 892 (0-indexed) exceeds the archive size
+# (891) by two frames. This script fixes that line by truncating the range 
+# to 890.
+
+if (scalar @ARGV != 1) {
+  my $usage = <<END;
+This script reads from stdin a feats.scp file that contains frame ranges and
+ensures that they don't exceed the maximum number of frames supplied in the
+<utt2max-frames> file. 
+
+Usage: $0 <utt2max-frames> < feats.scp > fixed_feats.scp
+END
+  die "$usage";
+}
+
+my $utt2max_frames_file = $ARGV[0];
+
+open MAX_FRAMES, $utt2max_frames_file or die "$0: Could not open file $utt2max_frames_file";
+
+my %utt2max_frames;
+
+while (<MAX_FRAMES>) {
+  chomp;
+  my @F = split;
+  
+  (scalar @F == 2) or die "$0: Invalid line $_ in $utt2max_frames_file";
+
+  $utt2max_frames{$F[0]} = $F[1];
+}
+
+while (<STDIN>) {
+  my $line = $_;
+  
+  #if (m/\[([^][]*)\]\[([^][]*)\]\s*$/) {
+  #  print STDERR ("fix_subsegment_feats.pl: this script only supports single indices");
+  #  exit(1);
+  #}
+  
+  my $before_range = "";
+  my $range = "";
+
+  if (m/^(.*)\[([^][]*)\]\s*$/) {
+    $before_range = $1;
+    $range = $2;
+  } else {
+    print;
+    next;
+  }
+
+  my @F = split(/ /, $before_range);
+  my $utt = shift @F;
+  defined $utt2max_frames{$utt} or die "fix_subsegment_feats.pl: Could not find key $utt in $utt2max_frames_file.\nError with line $line";
+
+  if ($range !~ m/^(\d*):(\d*)([,]?.*)$/) {
+    print STDERR "fix_subsegment_feats.pl: could not make sense of input line $_";
+    exit(1);
+  }
+    
+  my $row_start = $1;
+  my $row_end = $2;
+  my $col_range = $3;
+  
+  if ($row_start >= $utt2max_frames{$utt}) {
+    print STDERR "Removing $utt because row_start $row_start >= file max length $utt2max_frames{$utt}\n";
+    next;
+  }  
+  if ($row_end >= $utt2max_frames{$utt}) {
+    print STDERR "Fixed row_end for $utt from $row_end to $utt2max_frames{$utt}-1\n";
+    $row_end = $utt2max_frames{$utt} - 1;
+  } 
+   
+  if ($row_start ne "") {
+    $range = "$row_start:$row_end";
+  } else {
+    $range = "";
+  }
+
+  if ($col_range ne "") {
+    $range .= ",$col_range";
+  }
+  print ("$utt " . join(" ", @F) . "[" . $range . "]\n");
+}

UniAudio/UniAudio/egs/SE/utils/data/get_allowed_durations.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+
+# Copyright     2017  Hossein Hadian
+#               2019  Facebook Inc. (Author: Vimal Manohar)
+# Apache 2.0
+
+
+""" This script generates a set of allowed lengths of utterances
+    spaced by a factor (like 10%). This is useful for generating
+    fixed-length chunks for chain training.
+"""
+
+import argparse
+import os
+import sys
+import copy
+import math
+import logging
+
+sys.path.insert(0, 'steps')
+import libs.common as common_lib
+
+logger = logging.getLogger('libs')
+logger.setLevel(logging.INFO)
+handler = logging.StreamHandler()
+handler.setLevel(logging.INFO)
+formatter = logging.Formatter("%(asctime)s [%(pathname)s:%(lineno)s - "
+                              "%(funcName)s - %(levelname)s ] %(message)s")
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+def get_args():
+    parser = argparse.ArgumentParser(description="""
+    This script creates a list of allowed durations of utterances for flatstart
+    LF-MMI training corresponding to input data directory 'data_dir' and writes
+    it in two files in output directory 'dir':
+    1) allowed_durs.txt -- durations are in seconds
+    2) allowed_lengths.txt -- lengths are in number of frames
+
+    Both the allowed_durs.txt and allowed_lengths.txt are formatted to
+    have one entry on each line. Examples are as follows:
+
+    $ echo data/train/allowed_lengths.txt
+    414
+    435
+    468
+
+    $ echo data/train/allowed_durs.txt
+    4.16
+    4.37
+    4.70
+
+    These files can then be used by a downstream script to perturb the
+    utterances to these lengths.
+    A perturbed data directory (created by a downstream script
+    similar to utils/data/perturb_speed_to_allowed_lengths.py)
+    that only contains utterances of these allowed durations,
+    along with the corresponding allowed_lengths.txt are
+    consumed by the e2e chain egs preparation script.
+    See steps/nnet3/chain/e2e/get_egs_e2e.sh for how these are used.
+
+    See also:
+    * egs/cifar/v1/image/get_allowed_lengths.py -- a similar script for OCR datasets
+    * utils/data/perturb_speed_to_allowed_lengths.py --
+        creates the allowed_lengths.txt AND perturbs the data directory
+    """)
+    parser.add_argument('factor', type=float, default=12,
+                        help='Spacing (in percentage) between allowed lengths. '
+                        'Can be 0, which means all seen lengths that are a multiple of '
+                        'frame_subsampling_factor will be allowed.')
+    parser.add_argument('data_dir', type=str, help='path to data dir. Assumes that '
+                        'it contains the utt2dur file.')
+    parser.add_argument('dir', type=str, help='We write the output files '
+                        'allowed_lengths.txt and allowed_durs.txt to this directory.')
+    parser.add_argument('--coverage-factor', type=float, default=0.05,
+                        help="""Percentage of durations not covered from each
+                             side of duration histogram.""")
+    parser.add_argument('--frame-shift', type=int, default=10,
+                        help="""Frame shift in milliseconds.""")
+    parser.add_argument('--frame-length', type=int, default=25,
+                        help="""Frame length in milliseconds.""")
+    parser.add_argument('--frame-subsampling-factor', type=int, default=3,
+                        help="""Chain frame subsampling factor.
+                             See steps/nnet3/chain/train.py""")
+    args = parser.parse_args()
+    return args
+
+
+def read_kaldi_mapfile(path):
+    """ Read any Kaldi mapping file - like text, .scp files, etc.
+    """
+
+    m = {}
+    with open(path, 'r', encoding='latin-1') as f:
+        for line in f:
+            line = line.strip(" \t\r\n")
+            sp_pos = line.find(' ')
+            key = line[:sp_pos]
+            val = line[sp_pos+1:]
+            m[key] = val
+    return m
+
+
+def find_duration_range(utt2dur, coverage_factor):
+    """Given a list of utterance durations, find the start and end duration to cover
+
+     If we try to cover
+     all durations which occur in the training set, the number of
+     allowed lengths could become very large.
+
+     Returns
+     -------
+     start_dur: float
+     end_dur: float
+    """
+    durs = [float(val) for key, val in utt2dur.items()]
+    durs.sort()
+    to_ignore_dur = 0
+    tot_dur = sum(durs)
+    for d in durs:
+        to_ignore_dur += d
+        if to_ignore_dur * 100.0 / tot_dur > coverage_factor:
+            start_dur = d
+            break
+    to_ignore_dur = 0
+    for d in reversed(durs):
+        to_ignore_dur += d
+        if to_ignore_dur * 100.0 / tot_dur > coverage_factor:
+            end_dur = d
+            break
+    if start_dur < 0.3:
+        start_dur = 0.3  # a hard limit to avoid too many allowed lengths --not critical
+    return start_dur, end_dur
+
+
+def get_allowed_durations(start_dur, end_dur, args):
+    """Given the start and end duration, find a set of
+       allowed durations spaced by args.factor%. Also write
+       out the list of allowed durations and the corresponding
+       allowed lengths (in frames) on disk.
+
+     Returns
+     -------
+     allowed_durations: list of allowed durations (in seconds)
+    """
+
+    allowed_durations = []
+    d = start_dur
+    with open(os.path.join(args.dir, 'allowed_durs.txt'), 'w', encoding='latin-1') as durs_fp, \
+           open(os.path.join(args.dir, 'allowed_lengths.txt'), 'w', encoding='latin-1') as lengths_fp:
+        while d < end_dur:
+            length = int(d * 1000 - args.frame_length) / args.frame_shift + 1
+            if length % args.frame_subsampling_factor != 0:
+                length = (args.frame_subsampling_factor *
+                              (length // args.frame_subsampling_factor))
+                d = (args.frame_shift * (length - 1.0)
+                     + args.frame_length + args.frame_shift / 2) / 1000.0
+            allowed_durations.append(d)
+            durs_fp.write("{}\n".format(d))
+            lengths_fp.write("{}\n".format(int(length)))
+            d *= args.factor
+    return allowed_durations
+
+
+def get_trivial_allowed_durations(utt2dur, args):
+    lengths = list(set(
+        [int(float(d) * 1000 - args.frame_length) / args.frame_shift + 1
+         for key, d in utt2dur.items()]
+    ))
+    lengths.sort()
+
+    allowed_durations = []
+    with open(os.path.join(args.dir, 'allowed_durs.txt'), 'w', encoding='latin-1') as durs_fp, \
+           open(os.path.join(args.dir, 'allowed_lengths.txt'), 'w', encoding='latin-1') as lengths_fp:
+        for length in lengths:
+            if length % args.frame_subsampling_factor != 0:
+                length = (args.frame_subsampling_factor *
+                              (length // args.frame_subsampling_factor))
+                d = (args.frame_shift * (length - 1.0)
+                     + args.frame_length + args.frame_shift / 2) / 1000.0
+            allowed_durations.append(d)
+            durs_fp.write("{}\n".format(d))
+            lengths_fp.write("{}\n".format(int(length)))
+
+    assert len(allowed_durations) > 0
+    start_dur = allowed_durations[0]
+    end_dur = allowed_durations[-1]
+
+    logger.info("Durations in the range [{},{}] will be covered."
+                "".format(start_dur, end_dur))
+    logger.info("There will be {} unique allowed lengths "
+                "for the utterances.".format(len(allowed_durations)))
+
+    return allowed_durations
+
+
+def main():
+    args = get_args()
+    utt2dur = read_kaldi_mapfile(os.path.join(args.data_dir, 'utt2dur'))
+
+    if args.factor == 0.0:
+        get_trivial_allowed_durations(utt2dur, args)
+        return
+
+    args.factor = 1.0 + args.factor / 100.0
+
+    start_dur, end_dur = find_duration_range(utt2dur, args.coverage_factor)
+    logger.info("Durations in the range [{},{}] will be covered. "
+                "Coverage rate: {}%".format(start_dur, end_dur,
+                                      100.0 - args.coverage_factor * 2))
+    logger.info("There will be {} unique allowed lengths "
+                "for the utterances.".format(int(math.log(end_dur / start_dur)/
+                                                 math.log(args.factor))))
+
+    get_allowed_durations(start_dur, end_dur, args)
+
+
+if __name__ == '__main__':
+      main()

UniAudio/UniAudio/egs/SE/utils/data/get_frame_shift.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+
+# Copyright 2016  Johns Hopkins University (author: Daniel Povey)
+# Apache 2.0
+
+# This script takes as input a data directory, such as data/train/, preferably
+# with utt2dur file already existing (or the utt2dur file will be created if
+# not), and it attempts to work out the approximate frame shift by comparing the
+# utt2dur with the output of feat-to-len on the feats.scp.  It prints it out.
+# if the shift is very close to, but above, 0.01 (the normal frame shift) it
+# rounds it down.
+
+. utils/parse_options.sh
+. ./path.sh
+
+if [ $# != 1 ]; then
+  cat >&2 <<EOF
+Usage: frame_shift=\$($0 <datadir>)
+e.g.:  frame_shift=\$($0 data/train)
+
+This script prints the frame-shift in seconds (e.g. 0.01) to the standard out.
+Its output is intended to be captured in a shell variable.
+
+If <datadir> does not contain the file utt2dur, this script may invoke
+utils/data/get_utt2dur.sh, which will require write permission to <datadir>.
+EOF
+  exit 1
+fi
+
+export LC_ALL=C
+
+dir=$1
+
+if [[ -s $dir/frame_shift ]]; then
+  cat $dir/frame_shift
+  exit
+fi
+
+if [ ! -f $dir/feats.scp ]; then
+  echo "$0: $dir/feats.scp does not exist" 1>&2
+  exit 1
+fi
+
+if [ ! -s $dir/utt2dur ]; then
+  if [ ! -e $dir/wav.scp ] && [ ! -s $dir/segments ]; then
+    echo "$0: neither $dir/wav.scp nor $dir/segments exist; assuming a frame shift of 0.01." 1>&2
+    echo 0.01
+    exit 0
+  fi
+  echo "$0: $dir/utt2dur does not exist: creating it" 1>&2
+  utils/data/get_utt2dur.sh 1>&2 $dir || exit 1
+fi
+
+temp=$(mktemp /tmp/tmp.XXXX) || exit 1
+
+feat-to-len --print-args=false "scp:head -n 10 $dir/feats.scp|" ark,t:- > $temp
+
+if [[ ! -s $temp ]]; then
+  rm $temp
+  echo "$0: error running feat-to-len" 1>&2
+  exit 1
+fi
+
+frame_shift=$(head -n 10 $dir/utt2dur | paste - $temp | awk '
+      { dur += $2; frames += $4; }
+  END { shift = dur / frames;
+        if (shift > 0.01 && shift < 0.0102) shift = 0.01;
+        print shift; }') || exit 1;
+
+rm $temp
+
+echo $frame_shift > $dir/frame_shift
+echo $frame_shift
+exit 0

UniAudio/UniAudio/egs/SE/utils/data/get_num_frames.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+# This script works out the approximate number of frames in a training directory.
+# This is sometimes needed by higher-level scripts
+
+
+if [ -f path.sh ]; then . ./path.sh; fi
+. parse_options.sh || exit 1;
+
+if [ $# -ne 1 ]; then
+  (
+    echo "Usage: $0 <data-dir>"
+    echo "Prints the number of frames of data in the data-dir"
+  ) 1>&2
+fi
+
+data=$1
+
+if [ ! -f $data/utt2dur ]; then
+  utils/data/get_utt2dur.sh $data 1>&2 || exit 1
+fi
+
+frame_shift=$(utils/data/get_frame_shift.sh $data) || exit 1
+
+awk -v s=$frame_shift '{n += $2} END{printf("%.0f\n", (n / s))}' <$data/utt2dur

UniAudio/UniAudio/egs/SE/utils/data/get_reco2dur.sh

@@ -0,0 +1,143 @@
+#!/usr/bin/env bash
+
+# Copyright 2016  Johns Hopkins University (author: Daniel Povey)
+#           2018  Andrea Carmantini
+# Apache 2.0
+
+# This script operates on a data directory, such as in data/train/, and adds the
+# reco2dur file if it does not already exist.  The file 'reco2dur' maps from
+# recording to the duration of the recording in seconds.  This script works it
+# out from the 'wav.scp' file, or, if utterance-ids are the same as recording-ids, from the
+# utt2dur file (it first tries interrogating the headers, and if this fails, it reads the wave
+# files in entirely.)
+# We could use durations from segments file, but that's not the duration of the recordings
+# but the sum of utterance lenghts (silence in between could be excluded from segments)
+# For sum of utterance lenghts:
+# awk 'FNR==NR{uttdur[$1]=$2;next}
+# { for(i=2;i<=NF;i++){dur+=uttdur[$i];}
+#   print $1 FS dur; dur=0  }'  $data/utt2dur $data/reco2utt
+
+
+frame_shift=0.01
+cmd=run.pl
+nj=4
+
+. utils/parse_options.sh
+. ./path.sh
+
+if [ $# != 1 ]; then
+  echo "Usage: $0 [options] <datadir>"
+  echo "e.g.:"
+  echo " $0 data/train"
+  echo " Options:"
+  echo " --frame-shift      # frame shift in seconds. Only relevant when we are"
+  echo "                    # getting duration from feats.scp (default: 0.01). "
+  exit 1
+fi
+
+export LC_ALL=C
+
+data=$1
+
+
+if [ -s $data/reco2dur ] && \
+  [ $(wc -l < $data/wav.scp) -eq $(wc -l < $data/reco2dur) ]; then
+  echo "$0: $data/reco2dur already exists with the expected length.  We won't recompute it."
+  exit 0;
+fi
+
+if [ -s $data/utt2dur ] && \
+   [ $(wc -l < $data/utt2spk) -eq $(wc -l < $data/utt2dur) ] && \
+   [ ! -s $data/segments ]; then
+
+  echo "$0: $data/wav.scp indexed by utt-id; copying utt2dur to reco2dur"
+  cp $data/utt2dur $data/reco2dur && exit 0;
+
+elif [ -f $data/wav.scp ]; then
+  echo "$0: obtaining durations from recordings"
+
+  # if the wav.scp contains only lines of the form
+  # utt1  /foo/bar/sph2pipe -f wav /baz/foo.sph |
+  if cat $data/wav.scp | perl -e '
+     while (<>) { s/\|\s*$/ |/;  # make sure final | is preceded by space.
+             @A = split; if (!($#A == 5 && $A[1] =~ m/sph2pipe$/ &&
+                               $A[2] eq "-f" && $A[3] eq "wav" && $A[5] eq "|")) { exit(1); }
+             $reco = $A[0]; $sphere_file = $A[4];
+
+             if (!open(F, "<$sphere_file")) { die "Error opening sphere file $sphere_file"; }
+             $sample_rate = -1;  $sample_count = -1;
+             for ($n = 0; $n <= 30; $n++) {
+                $line = <F>;
+                if ($line =~ m/sample_rate -i (\d+)/) { $sample_rate = $1; }
+                if ($line =~ m/sample_count -i (\d+)/) { $sample_count = $1; }
+                if ($line =~ m/end_head/) { break; }
+             }
+             close(F);
+             if ($sample_rate == -1 || $sample_count == -1) {
+               die "could not parse sphere header from $sphere_file";
+             }
+             $duration = $sample_count * 1.0 / $sample_rate;
+             print "$reco $duration\n";
+     } ' > $data/reco2dur; then
+    echo "$0: successfully obtained recording lengths from sphere-file headers"
+  else
+    echo "$0: could not get recording lengths from sphere-file headers, using wav-to-duration"
+    if ! command -v wav-to-duration >/dev/null; then
+      echo  "$0: wav-to-duration is not on your path"
+      exit 1;
+    fi
+
+    read_entire_file=false
+    if grep -q 'sox.*speed' $data/wav.scp; then
+      read_entire_file=true
+      echo "$0: reading from the entire wav file to fix the problem caused by sox commands with speed perturbation. It is going to be slow."
+      echo "... It is much faster if you call get_reco2dur.sh *before* doing the speed perturbation via e.g. perturb_data_dir_speed.sh or "
+      echo "... perturb_data_dir_speed_3way.sh."
+    fi
+
+    num_recos=$(wc -l <$data/wav.scp)
+    if [ $nj -gt $num_recos ]; then
+      nj=$num_recos
+    fi
+
+    temp_data_dir=$data/wav${nj}split
+    wavscps=$(for n in `seq $nj`; do echo $temp_data_dir/$n/wav.scp; done)
+    subdirs=$(for n in `seq $nj`; do echo $temp_data_dir/$n; done)
+
+    if ! mkdir -p $subdirs >&/dev/null; then
+	for n in `seq $nj`; do
+	    mkdir -p $temp_data_dir/$n
+	done
+    fi
+
+    utils/split_scp.pl $data/wav.scp $wavscps
+
+
+    $cmd JOB=1:$nj $data/log/get_reco_durations.JOB.log \
+      wav-to-duration --read-entire-file=$read_entire_file \
+      scp:$temp_data_dir/JOB/wav.scp ark,t:$temp_data_dir/JOB/reco2dur || \
+        { echo "$0: there was a problem getting the durations"; exit 1; } # This could
+
+    for n in `seq $nj`; do
+      cat $temp_data_dir/$n/reco2dur
+    done > $data/reco2dur
+  fi
+  rm -r $temp_data_dir
+else
+  echo "$0: Expected $data/wav.scp to exist"
+  exit 1
+fi
+
+len1=$(wc -l < $data/wav.scp)
+len2=$(wc -l < $data/reco2dur)
+if [ "$len1" != "$len2" ]; then
+  echo "$0: warning: length of reco2dur does not equal that of wav.scp, $len2 != $len1"
+  if [ $len1 -gt $[$len2*2] ]; then
+    echo "$0: less than half of recordings got a duration: failing."
+    exit 1
+  fi
+fi
+
+echo "$0: computed $data/reco2dur"
+
+exit 0

UniAudio/UniAudio/egs/SE/utils/data/get_reco2utt_for_data.sh

@@ -0,0 +1,21 @@
+#! /bin/bash
+
+# Copyright 2016  Vimal Manohar
+# Apache 2.0
+
+if [ $# -ne 1 ]; then
+  echo "This script outputs a mapping from recording to a list of utterances "
+  echo "corresponding to the recording. It is analogous to the content of "
+  echo "a spk2utt file, but is indexed by recording instead of speaker."
+  echo "Usage: get_reco2utt.sh <data>"
+  echo " e.g.: get_reco2utt.sh data/train"
+  exit 1
+fi
+
+data=$1
+
+if [ ! -s $data/segments ]; then
+  utils/data/get_segments_for_data.sh $data > $data/segments
+fi
+
+cut -d ' ' -f 1,2 $data/segments | utils/utt2spk_to_spk2utt.pl

UniAudio/UniAudio/egs/SE/utils/data/get_segments_for_data.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+# This script operates on a data directory, such as in data/train/,
+# and writes new segments to stdout. The file 'segments' maps from
+# utterance to time offsets into a recording, with the format:
+#   <utterance-id> <recording-id> <segment-begin> <segment-end>
+# This script assumes utterance and recording ids are the same (i.e., that
+# wav.scp is indexed by utterance), and uses durations from 'utt2dur', 
+# created if necessary by get_utt2dur.sh.
+
+. ./path.sh
+
+if [ $# != 1 ]; then
+  echo "Usage: $0 [options] <datadir>"
+  echo "e.g.:"
+  echo " $0 data/train > data/train/segments"
+  exit 1
+fi
+
+data=$1
+
+if [ ! -s $data/utt2dur ]; then
+  utils/data/get_utt2dur.sh $data 1>&2 || exit 1;
+fi
+
+# <utt-id> <utt-id> 0 <utt-dur>
+awk '{ print $1, $1, 0, $2 }' $data/utt2dur
+
+exit 0

UniAudio/UniAudio/egs/SE/utils/data/get_uniform_subsegments.py

@@ -0,0 +1,121 @@
+#! /usr/bin/env python
+
+# Copyright 2017  Vimal Manohar
+#           2017  Matthew Maciejewski
+# Apache 2.0.
+
+from __future__ import print_function
+import argparse
+import logging
+import sys
+import textwrap
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        description=textwrap.dedent("""
+        Creates a subsegments file from an input segments file.
+
+        The output format is
+
+        <subsegment-id> <utterance-id> <start-time> <end-time>,
+
+        where the timings are relative to the start-time of the
+         <utterance-id> in the input segments file.
+        Reminder: the format of the input segments file is:
+
+         <utterance-id> <recording-id> <start-time> <end-time>
+
+        where the recording-id corresponds to a wav file (or a channel of
+        a wav file) from wav.scp.  Note: you can use
+        utils/data/get_segments_for_data.sh to generate a 'default'
+        segments file for your data if one doesn't already exist.
+
+        e.g.: get_uniform_subsegments.py data/dev/segments > \\
+                data/dev_uniform_segments/sub_segments
+
+        utils/data/subsegment_data_dir.sh data/dev \\
+            data/dev_uniform_segments/sub_segments data/dev_uniform_segments
+
+        The output is written to stdout. The resulting file can be
+        passed to utils/data/subsegment_data_dir.sh to sub-segment
+        the data directory."""),
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--max-segment-duration", type=float,
+                        default=30, help="""Maximum duration of the
+                        subsegments (in seconds)""")
+    parser.add_argument("--overlap-duration", type=float,
+                        default=5, help="""Overlap between
+                        adjacent segments (in seconds)""")
+    parser.add_argument("--max-remaining-duration", type=float,
+                        default=10, help="""Segment is not split
+                        if the left-over duration is more than this
+                        many seconds""")
+    parser.add_argument("--constant-duration", type=bool,
+                        default=False, help="""Final segment is given
+                        a start time max-segment-duration before the
+                        end to force a constant segment duration. This
+                        overrides the max-remaining-duration parameter""")
+    parser.add_argument("segments_file", type=argparse.FileType('r'),
+                        help="""Input kaldi segments file""")
+
+    args = parser.parse_args()
+    return args
+
+
+def run(args):
+    if (args.constant_duration):
+        dur_threshold = args.max_segment_duration
+    else:
+        dur_threshold = args.max_segment_duration + args.max_remaining_duration
+
+    for line in args.segments_file:
+        parts = line.strip().split()
+        utt_id = parts[0]
+        start_time = float(parts[2])
+        end_time = float(parts[3])
+
+        dur = end_time - start_time
+
+        start = start_time
+        while (dur > dur_threshold):
+            end = start + args.max_segment_duration
+            start_relative = start - start_time
+            end_relative = end - start_time
+            new_utt = "{utt_id}-{s:08d}-{e:08d}".format(
+                utt_id=utt_id, s=int(100 * start_relative),
+                e=int(100 * end_relative))
+            print ("{new_utt} {utt_id} {s:.3f} {e:.3f}".format(
+                new_utt=new_utt, utt_id=utt_id, s=start_relative,
+                e=start_relative + args.max_segment_duration))
+            start += args.max_segment_duration - args.overlap_duration
+            dur -= args.max_segment_duration - args.overlap_duration
+
+        if (args.constant_duration):
+            if (dur < 0):
+              continue
+            if (dur < args.max_remaining_duration):
+              start = max(end_time - args.max_segment_duration, start_time)
+            end = min(start + args.max_segment_duration, end_time)
+        else:
+            end = end_time
+        new_utt = "{utt_id}-{s:08d}-{e:08d}".format(
+            utt_id=utt_id, s=int(round(100 * (start - start_time))),
+            e=int(round(100 * (end - start_time))))
+        print ("{new_utt} {utt_id} {s:.3f} {e:.3f}".format(
+            new_utt=new_utt, utt_id=utt_id, s=start - start_time,
+            e=end - start_time))
+
+
+def main():
+    args = get_args()
+    try:
+        run(args)
+    except Exception:
+        logging.error("Failed creating subsegments", exc_info=True)
+        raise SystemExit(1)
+    finally:
+        args.segments_file.close()
+
+
+if __name__ == '__main__':
+    main()