def testFloatVectorReadWrite(self): """ Test read/write for float vectors. """ # read, flt_vec = { k: v for k, v in kaldi_io.read_vec_flt_scp('tests/data/conf.scp') } # scp, return flt_vec2 = { k: v for k, v in kaldi_io.read_vec_flt_ark('tests/data/conf.ark') } # binary-ark, flt_vec3 = { k: v for k, v in kaldi_io.read_vec_flt_ark('tests/data/conf_ascii.ark') } # ascii-ark, # store, with kaldi_io.open_or_fd('tests/data_re-saved/conf.ark', 'wb') as f: for k, v in flt_vec.items(): kaldi_io.write_vec_flt(f, v, k) # read and compare, for k, v in kaldi_io.read_vec_flt_ark('tests/data_re-saved/conf.ark'): self.assertTrue(np.array_equal(v, flt_vec[k]), msg="flt. vector same after re-saving")
def test_modified_arks(self): original_ark_paths = glob.glob('data/kaldi/*.ark') for original_ark_path in original_ark_paths: modified_ark_paths = glob.glob('data/kaldi/modified/*' + os.path.basename(original_ark_path)) original_ark = kaldi_io.read_vec_flt_ark(original_ark_path) modified_arks = [kaldi_io.read_vec_flt_ark(ark_path) for ark_path in modified_ark_paths] for original_key, original_vector in original_ark: for modified_ark in modified_arks: modified_key, modified_vector = next(modified_ark) self.assertEqual(original_key, modified_key)
def err_per_phone(flags_fname, scores_fname, threshold, text_fname, phn_map, misp_trend): flags_dict = {k: v for k, v in kio.read_vec_int_ark(flags_fname)} text_dict = {k: v for k, v in kio.read_vec_int_ark(text_fname)} far = np.zeros((len(phn_map), len(threshold)), dtype=np.int32) frr = np.zeros((len(phn_map), len(threshold)), dtype=np.int32) cnt_mp = np.zeros(len(phn_map), dtype=np.int32) cnt_cp = np.zeros(len(phn_map), dtype=np.int32) for utt_id, scores in kio.read_vec_flt_ark(scores_fname): flags = flags_dict[utt_id] phones = text_dict[utt_id] for i in range(len(flags)): if flags[i] > 2: continue phn = phones[i] mp = misp_fn[misp_trend](scores[i], threshold) if flags[i] == 0: cnt_cp[phn] += 1 frr[phn, mp == True] = frr[phn, mp == True] + 1 elif flags[i] > 0: cnt_mp[phn] += 1 far[phn, mp == False] = far[phn, mp == False] + 1 cnt_mp = cnt_mp.astype(np.float) cnt_cp = cnt_cp.astype(np.float) cnt_mp[cnt_mp == 0.] = float('nan') cnt_cp[cnt_cp == 0.] = float('nan') cnt_mp = np.reshape(cnt_mp, (-1, 1)) cnt_cp = np.reshape(cnt_cp, (-1, 1)) return (far / cnt_mp), (frr / cnt_cp)
def err(flags_fname, scores_fname, threshold, misp_trend): flags_dict = {k: v for k, v in kio.read_vec_int_ark(flags_fname)} far = np.zeros_like(threshold, dtype=np.int32) frr = np.zeros_like(threshold, dtype=np.int32) cnt_mp = 0 cnt_cp = 0 for uttid, scores in kio.read_vec_flt_ark(scores_fname): flags = flags_dict[uttid] for i in range(len(flags)): if flags[i] > 2: continue mp = misp_fn[misp_trend](scores[i], threshold) if flags[i] == 0: cnt_cp += 1 # correct[mp == False] = correct[mp == False] + 1 frr[mp == True] += 1 elif flags[i] > 0: cnt_mp = cnt_mp + 1 # correct[mp == True] = correct[mp == True] + 1 far[mp == False] = far[mp == False] + 1 else: print("Imposible?!") return (far / cnt_mp), (frr / cnt_cp)
def save_predict_result(predict_result, opath2result): """ format result and save it to opath2result the output should be formated as follows. Kazak Kazak_F0101033 6.049543 Tibet Kazak_F0101033 1.100619 Uyghu Kazak_F0101033 5.243432 ct Kazak_F0101033 -0.9423696 id Kazak_F0101033 -3.326587 ja Kazak_F0101033 -0.8206892 ko Kazak_F0101033 -3.42079 ru Kazak_F0101033 3.852252 vi Kazak_F0101033 -2.77112 zh Kazak_F0101033 -0.8504514 ... Note that the first two columns should have exactly the same format as above. Otherwise, it will cause logical bugs when the result is further used in other bash sciprts. """ lang_list = ['Kazak', 'Tibet', 'Uyghu', 'ct', 'id', 'ja', 'ko', 'ru', 'vi', 'zh'] lang_len = len(lang_list) print(">> Save score result to %s" %opath2result) with open(opath2result, 'w') as f: for utt_idx, (uttid, _) in enumerate(kaldi_io.read_vec_flt_ark(ipath2testset)): for lang_idx, lang in enumerate(lang_list): f.write("%s %s %.6f\n" %(lang_list[lang_idx], uttid, predict_result[utt_idx, lang_idx]))
def testFloatVectorReadWrite(self): """ Test read/write for float vectors. """ # read, flt_vec = { k:v for k,v in kaldi_io.read_vec_flt_scp('tests/data/conf.scp') } # scp, return flt_vec2 = { k:v for k,v in kaldi_io.read_vec_flt_ark('tests/data/conf.ark') } # binary-ark, flt_vec3 = { k:v for k,v in kaldi_io.read_vec_flt_ark('tests/data/conf_ascii.ark') } # ascii-ark, # store, with kaldi_io.open_or_fd('tests/data_re-saved/conf.ark','wb') as f: for k,v in flt_vec.items(): kaldi_io.write_vec_flt(f, v, k) # read and compare, for k,v in kaldi_io.read_vec_flt_ark('tests/data_re-saved/conf.ark'): self.assertTrue(np.array_equal(v,flt_vec[k]), msg="flt. vector same after re-saving")
def load_ary_arkfile(arkfile): key = [] val = [] for k, v in kaldi_io.read_vec_flt_ark(arkfile): key.append(k) val.append(v) return key, val
def read_to_vec(self, type='int'): print("run", self.cmd) if type == 'int': generator = kaldi_io.read_vec_int_ark(self.cmd) if type == 'float': generator = kaldi_io.read_vec_flt_ark(self.cmd) result = {utt_id: np.array(vec) for utt_id, vec in generator} return result
def read_args(args): segments, labels = read_labels_file(args.input_label_file) xvec_all = dict(kaldi_io.read_vec_flt_ark(args.xvector_ark_file)) xvectors = [] for segment in segments: xvectors.append(xvec_all[segment]) _, _, plda_psi = kaldi_io.read_plda(args.plda) return xvectors, segments, labels, plda_psi
def plda_read(self,plda): with kaldi_io.open_or_fd(plda,'rb') as f: for key,vec in kaldi_io.read_vec_flt_ark(f): if key == 'mean': self.mean = vec.reshape(-1,1) self.dim = self.mean.shape[0] elif key == 'within_var': self.within_var = vec.reshape(self.dim, self.dim) else: self.between_var = vec.reshape(self.dim, self.dim)
def convert_to_npy(datatype, arkscppath, outputnpyfilepath, file_list_path): if not os.path.isdir(outputnpyfilepath): print('Creating directory where npy scores will be saved : {}'.format( outputnpyfilepath)) os.makedirs(outputnpyfilepath) else: print("xvectors numpy path exists !") # exit() file_name = os.path.basename(arkscppath) ext = os.path.splitext(file_name)[1] if datatype == 'mat': #for score files if ext == ".scp": d = {key: mat for key, mat in kaldi_io.read_mat_scp(arkscppath)} else: print("File type not correct. scp required.") elif datatype == 'vec': #for embeddings if ext == ".scp": d = { key: mat for key, mat in kaldi_io.read_vec_flt_scp(arkscppath) } elif ext == ".ark": d = { key: mat for key, mat in kaldi_io.read_vec_flt_ark(arkscppath) } else: print("File type not correct. scp/ark required.") else: print("first argument should be mat/vec ") file_list = open(file_list_path, 'r').readlines() file_count = 0 for count, (i, j) in enumerate(d.items()): if count == 0: system = j.reshape(1, -1) # if count % 100 == 0: # print("Done with {} files".format(count)) fn = file_list[file_count].rsplit()[0] if fn in i: system = np.vstack((system, j)) else: print('fielname:', fn) if not os.path.isfile(outputnpyfilepath + '/' + fn + '.npy'): np.save(outputnpyfilepath + '/' + fn + '.npy', system) file_count = file_count + 1 system = j.reshape(1, -1) # last file print('fielname:', fn) if not os.path.isfile(outputnpyfilepath + '/' + fn + '.npy'): np.save(outputnpyfilepath + '/' + fn + '.npy', system)
def read_vec(filename): try: temp_dict = {} for key, vec in kaldi_io.read_vec_flt_ark(filename): if temp_dict.has_key(key): raise Exception("duplicated key") else: temp_dict[key] = vec return temp_dict except Exception, e: print(str(e)) return False
def read_args(args): segments, labels = read_labels_file(args.input_label_file) xvec_all = dict(kaldi_io.read_vec_flt_ark(args.xvector_ark_file)) xvectors = [] for segment in segments: xvectors.append(xvec_all[segment]) _, _, plda_psi = kaldi_io.read_plda(args.plda) if (args.overlap_rttm is not None): print('Getting overlap segments...') overlaps = get_overlap_vector(args.overlap_rttm, segments) else: overlaps = None return xvectors, segments, labels, plda_psi, overlaps
def load_test_data_and_preprocess(ipath2testset): """ load ivectors, generate labels Return: a list of test set tuple (the first item is label(int), second is a float vector(list)) """ assert ipath2testset, "Empty ipath2testset!" testset = [] for uttid, vec in kaldi_io.read_vec_flt_ark(ipath2testset): langid = uttid[:5] assert langid in uttprefix2num_dict, "Invalid ivector utterance id: %s" %(uttid) testset.append( (uttprefix2num_dict[langid], vec) ) ## Note that normalization is skipped here ## as we can easily and already have normlized ivectors in kaldi print("test set size is: %d" %len(testset) ) return testset
def testPipeReadWrite(self): """ Test read/write for pipes. Note: make sure the "os.environ['KALDI_ROOT']" in "kaldi_io/kaldi_io.py" is correct. """ # the following line disables 'stderr' forwarding, comment it for DEBUG, with open("/dev/null","w") as sys.stderr: # read, flt_mat4 = { k:m for k,m in kaldi_io.read_mat_ark('ark:copy-feats ark:tests/data/feats.ark ark:- |') } # write to pipe, with kaldi_io.open_or_fd('ark:| copy-feats ark:- ark:tests/data_re-saved/mat_pipe.ark','wb') as f: for k,m in flt_mat4.items(): kaldi_io.write_mat(f, m, k) # read it again and compare, for k,m in kaldi_io.read_mat_ark('tests/data_re-saved/mat_pipe.ark'): self.assertTrue(np.array_equal(m, flt_mat4[k]),"flt. matrix same after read/write via pipe") # read some other formats from pipe, i32_vec3 = { k:v for k,v in kaldi_io.read_vec_int_ark('ark:copy-int-vector ark:tests/data/ali.ark ark:- |') } flt_vec4 = { k:v for k,v in kaldi_io.read_vec_flt_ark('ark:copy-vector ark:tests/data/conf.ark ark:- |') }
def load_train_data_and_preprocess(ipath2train_ivectors): """ load ivectors, generate labels, flush them, split into train and val sets Return: a list of train set tuple, a list of val set tuple where the first item is label(int), second is a float vector(list) """ assert ipath2train_ivectors, "Empty ipath2train_ivectors!" train_set = [] # a list of tuples where the first item is lanid, the second item is numpy vector (ivector) for uttid, vec in kaldi_io.read_vec_flt_ark(ipath2train_ivectors): langid = uttid[:5] assert langid in lang2num_dict, "Invalid ivector utterance id: %s" %(uttid) train_set.append( (lang2num_dict[langid], vec) ) ## Note that normalization is skipped here ## as we can easily and already have normlized ivectors in kaldi ## split into train and validation sets (includes flushing samples and splitting) trainset, validset = train_test_split(train_set, test_size=0.15, stratify=list(zip(*train_set))[0] ) print("train set size is: %d, valid set size is:%d " %(len(trainset), len(validset))) return trainset, validset
def testPipeReadWrite(self): """ Test read/write for pipes. Note: make sure the "os.environ['KALDI_ROOT']" in "kaldi_io/kaldi_io.py" is correct. """ # the following line disables 'stderr' forwarding, comment it for DEBUG, with open("/dev/null", "w") as sys.stderr: # read, flt_mat4 = { k: m for k, m in kaldi_io.read_mat_ark( 'ark:copy-feats ark:tests/data/feats.ark ark:- |') } # write to pipe, with kaldi_io.open_or_fd( 'ark:| copy-feats ark:- ark:tests/data_re-saved/mat_pipe.ark', 'wb') as f: for k, m in flt_mat4.items(): kaldi_io.write_mat(f, m, k) # read it again and compare, for k, m in kaldi_io.read_mat_ark( 'tests/data_re-saved/mat_pipe.ark'): self.assertTrue(np.array_equal(m, flt_mat4[k]), "flt. matrix same after read/write via pipe") # read some other formats from pipe, i32_vec3 = { k: v for k, v in kaldi_io.read_vec_int_ark( 'ark:copy-int-vector ark:tests/data/ali.ark ark:- |') } flt_vec4 = { k: v for k, v in kaldi_io.read_vec_flt_ark( 'ark:copy-vector ark:tests/data/conf.ark ark:- |') }
def main(): # gpu configuration toolkits.initialize_GPU(args) import model # ================================== # Get Model # ================================== # construct the data generator. params = {'dim': (23, None, 1), 'nfft': 512, 'spec_len': 250, 'win_length': 400, 'hop_length': 160, 'n_classes': 5994, 'sampling_rate': 16000, 'normalize': True, } network_eval = model.vggvox_resnet2d_icassp(input_dim=params['dim'], num_class=params['n_classes'], mode='eval', args=args) utt2ark, utt2idx, all_list, utt2data = {}, {}, [], {} for idx, kaldi_data_dir in enumerate(args.kaldi_data_dirs): if not os.path.exists(args.emb_out_dirs[idx]): os.makedirs(args.emb_out_dirs[idx]) feats_path = os.path.join(kaldi_data_dir, 'feats.scp') vad_path = os.path.join(kaldi_data_dir, 'vad.scp') assert os.path.exists(feats_path), 'Path `{}` does not exists.'.format(feats_path) with open(feats_path) as f: for line in f: key, ark = line.split() ark, position = ark.split(':') input_tuple = (key, ark, int(position)) utt2data[key] = ut.load_data(input_tuple, mode='eval') utt2idx[key] = idx with open(vad_path) as f: for line in f: key, ark = line.split() ark, position = ark.split(':') vad_array = None for ark_key, vec in kaldi_io.read_vec_flt_ark(ark): if key == ark_key: vad_array = np.array(vec, dtype=bool) assert vad_array is not None assert vad_array.size == utt2data[key].shape[1], 'Shapes does not fit: vad {}, mfcc {}'.format( vad_array.size, utt2data[key].shape[1]) utt2data[key] = ut.apply_cmvn_sliding(utt2data[key]).T[vad_array] # ==> load pre-trained model ??? if os.path.isfile(args.resume): network_eval.load_weights(os.path.join(args.resume), by_name=True) print('==> successfully loaded model {}.'.format(args.resume)) else: raise IOError("==> no checkpoint found at '{}'".format(args.resume)) print('==> start testing.') # The feature extraction process has to be done sample-by-sample, # because each sample is of different lengths. for idx, utt in enumerate(utt2data): embedding = network_eval.predict(utt2data[utt].T[np.newaxis, :, :, np.newaxis]).squeeze() ut.write_txt_vectors( os.path.join(args.emb_out_dirs[utt2idx[utt]], 'xvector.{}.txt'.format(idx)), {utt: embedding})
def __init__(self, ark_files, embeddings_file, embedding_source: EmbeddingSource): self.embedding_source = embedding_source self.speech_arks = [(os.path.basename(file_), kaldi_io.read_vec_flt_ark(file_)) for file_ in ark_files] self.multi_modal_embeddings = pd.read_csv(embeddings_file) self.multi_modal_embeddings[embedding_source.value] = self.multi_modal_embeddings[embedding_source.value].apply( literal_eval)
for k, v in kaldi_io.read_vec_int_ark('data/ali.ark')} # binary, i32_vec2 = {k: v for k, v in kaldi_io.read_vec_int_ark('data/ali_ascii.ark') } # ascii, # - store, with kaldi_io.open_or_fd('data_re-saved/ali.ark', 'wb') as f: for k, v in i32_vec.items(): kaldi_io.write_vec_int(f, v, k) # - read and compare, for k, v in kaldi_io.read_vec_int_ark('data_re-saved/ali.ark'): assert (np.array_equal(v, i32_vec[k])) print('testing float-vector i/o') flt_vec = {k: v for k, v in kaldi_io.read_vec_flt_scp('data/conf.scp')} # scp, flt_vec2 = {k: v for k, v in kaldi_io.read_vec_flt_ark('data/conf.ark') } # binary-ark, flt_vec3 = {k: v for k, v in kaldi_io.read_vec_flt_ark('data/conf_ascii.ark') } # ascii-ark, # - store, with kaldi_io.open_or_fd('data_re-saved/conf.ark', 'wb') as f: for k, v in flt_vec.items(): kaldi_io.write_vec_flt(f, v, k) # - read and compare, for k, v in kaldi_io.read_vec_flt_ark('data_re-saved/conf.ark'): assert (np.array_equal(v, flt_vec[k])) print('testing matrix i/o') flt_mat = {k: m for k, m in kaldi_io.read_mat_scp('data/feats_ascii.scp')
} parser = ArgumentParser() parser.add_argument('score1') parser.add_argument('score2') parser.add_argument('text') parser.add_argument('flags') parser.add_argument('--p1', type=int) parser.add_argument('--p2', type=int) parser.add_argument('--trans_1', dest='trans_1', type=Transformation, choices=list(Transformation), default=Transformation.none) parser.add_argument('--trans_2', dest='trans_2', type=Transformation, choices=list(Transformation), default=Transformation.none) args = parser.parse_args() score1_dict = {k:v for k,v in kio.read_vec_flt_ark(args.score1)} score2_dict = {k:v for k,v in kio.read_vec_flt_ark(args.score2)} trans1_fn = trans_fn[args.trans_1.value] trans2_fn = trans_fn[args.trans_2.value] text_dic = {k:v for k,v in kio.read_vec_int_ark(args.text)} score_subst = [] score_delet = [] score_correct = [] for key, flags in kio.read_vec_int_ark(args.flags): text = text_dic[key] score1 = trans1_fn(score1_dict[key]) score2 = trans2_fn(score2_dict[key])
dim = 0 for k,m in kaldi_io.read_mat_ark(LCPLDA_filename): dim = m.shape[1] #numcol vec = m[col_indx,:] lcplda_vec[k] = vec lcplda_vec2[k] = m[-1,:] # ignore discription item print("lclda_vec size is ",len(lclda_vec)-1) print("lcplda_vec size is ",len(lcplda_vec)-1) # read speaker mean into spk_mean spk_mean = {k:m for k,m in kaldi_io.read_vec_flt_ark(spkmean_filename)} print("spk_mean size is ",len(spk_mean)) # delete the empty item in spk_mean # key_list = spk_mean.keys() # for k in key_list: # if not k in lda_vec: # del spk_mean[k] # print("spk_mean size after deletion is ",len(spk_mean)) num_spk_ = len(spk_mean) # convert dict to array lclda_mat = np.empty([num_spk_, dim], dtype = float) lclda_mat2 = np.empty([num_spk_, dim], dtype = float) lcplda_mat = np.empty([num_spk_, dim], dtype = float)
if not os.path.isdir(outputnpyfilepath): print('Creating directory where npy scores will be saved : {}'.format( outputnpyfilepath)) os.makedirs(outputnpyfilepath) else: print("xvectors numpy path exists !") exit() ext = os.path.splitext(file_name)[1] if sys.argv[1] == 'mat': #for score files if ext == ".scp": d = {key: mat for key, mat in kaldi_io.read_mat_scp(arkscppath)} else: print("File type not correct. scp required.") elif sys.argv[1] == 'vec': #for embeddings if ext == ".scp": d = {key: mat for key, mat in kaldi_io.read_vec_flt_scp(arkscppath)} elif ext == ".ark": d = {key: mat for key, mat in kaldi_io.read_vec_flt_ark(arkscppath)} else: print("File type not correct. scp/ark required.") else: print("first argument should be mat/vec ") for count, (i, j) in enumerate(d.items()): if count % 100 == 0: print("Done with {} files".format(count)) np.save(outputnpyfilepath + '/' + i, j)
print >> sys.stderr, " input_vec_file ", input_vec_file print >> sys.stderr, " wh_matrix_file ", wh_matrix_file print >> sys.stderr, " co_matrix_file ", co_matrix_file print >> sys.stderr, " output_vec_file ", output_vec_file #print >> sys.stderr, "" else: print >> sys.stderr, "Usage:$0 ark:input.ark zca_whitening_matrix" print >> sys.stderr, " scp:input.scp zca_whitening_matrix" print >> sys.stderr, " ark:input.ark zca_whitening_matrix ark:output.ark" sys.exit() # load input if re.search('^ark:', input_vec_file): if input_vec_file[-1] == "-": vectors = list(kaldi_io.read_vec_flt_ark(sys.stdin)) else: vectors = list(kaldi_io.read_vec_flt_ark(input_vec_file)) elif re.search('^scp:', input_vec_file): if input_vec_file[-1] == "-": vectors = kaldi_io.read_vec_flt_scp(sys.stdin) else: vectors = kaldi_io.read_vec_flt_scp(input_vec_file) else: print >> sys.stderr, '[ERROR]: input_vec_file should be "ark:vector.ark" or "scp:vector.scp"' sys.exit() utt_ids = [uid for uid, vec in vectors] vectors = np.array([vec for uid, vec in vectors], dtype=np.float32).T # input i-vectors must be centerized !!!
from scipy.special import expit from scipy.special import logit from argparse import ArgumentParser # Parse arguments parser = ArgumentParser() parser.add_argument('output', help='output file') parser.add_argument('scores', nargs='+', help='score files') args = parser.parse_args() out_file = open(args.output, 'wb') # Open all score files scores_it = [] for score_fname in args.scores: x = kio.read_vec_flt_ark(score_fname) if next(x, None) is None: print("Invalid iterator", score_fname) scores_it.append(x) while True: # Get scores for the next utterance scores = [] for score_it in scores_it: try: key, values = next(score_it) scores.append(values) except StopIteration: print("Stop iterations") break s
for k, v in kaldi_io.read_vec_int_ark('data/ali.ark')} # binary, i32_vec2 = {k: v for k, v in kaldi_io.read_vec_int_ark('data/ali_ascii.ark') } # ascii, # - store, with kaldi_io.open_or_fd('data_re-saved/ali.ark', 'wb') as f: for k, v in i32_vec.items(): kaldi_io.write_vec_int(f, v, k) # - read and compare, for k, v in kaldi_io.read_vec_int_ark('data_re-saved/ali.ark'): assert (np.array_equal(v, i32_vec[k])) print('testing float-vector i/o') flt_vec = {k: v for k, v in kaldi_io.read_vec_flt_scp('data/conf.scp')} # scp, flt_vec2 = {k: v for k, v in kaldi_io.read_vec_flt_ark('data/conf.ark') } # binary-ark, flt_vec3 = {k: v for k, v in kaldi_io.read_vec_flt_ark('data/conf_ascii.ark') } # ascii-ark, # - store, with kaldi_io.open_or_fd('data_re-saved/conf.ark', 'wb') as f: for k, v in flt_vec.items(): kaldi_io.write_vec_flt(f, v, k) # - read and compare, for k, v in kaldi_io.read_vec_flt_ark('data_re-saved/conf.ark'): assert (np.array_equal(v, flt_vec[k])) print('testing matrix i/o') flt_mat = {k: m for k, m in kaldi_io.read_mat_scp('data/feats_ascii.scp')
def main(data_dir, mean_set, lda_set, lda_u2s, evl_cnd, trial_list_dir, lda_dim, out_dir, cohort_set): cohort_sizes = [58, 116, 232, 464, 928, 1856, 3712] if (mean_set != "None"): print(os.getcwd()) feat_rsp = "ark:{}/{}.ark".format(data_dir, mean_set) feats_generator = kaldi_io.read_vec_flt_ark(feat_rsp) mean_vec = np.mean([v for _, v in feats_generator], axis=0) #print(mean_vec.shape) elif (lda_set != "None"): print( "WARNING: No mean set provided. LDA set will be used for mean subtraction." ) feat_rsp = "ark:{}/{}.ark".format(data_dir, lda_set) feats_generator = kaldi_io.read_vec_flt_ark(feat_rsp) mean_vec = np.mean([v for _, v in feats_generator], axis=0) else: print("WARNING: No mean set provided. No mean will be subtracted.") if (lda_set != "None"): print("LDA IS NOT IMPLEMENTED.") sys.exit() else: print("WARNING: No LDA set provided. LDA will not be applied.") # Read in the cohort set feat_rsp = "ark:{}/{}.ark".format(data_dir, cohort_set) feats_generator = kaldi_io.read_vec_flt_ark(feat_rsp) coh = np.array([v for _, v in feats_generator]) print(coh.shape) if (mean_set != "None"): #enr -= mean_vec #tst -= mean_vec coh -= mean_vec coh /= np.sqrt(np.sum(coh**2, axis=1, keepdims=True)) / np.sqrt(256) with open(evl_cnd) as f: cnd = f.readlines() cnd = [c.rstrip() for c in cnd] for c in cnd: print(c) enrid2ind = {} enr = [] feat_rsp = "ark:{}/{}.enroll.ark".format(data_dir, c) feats_generator = kaldi_io.read_vec_flt_ark(feat_rsp) for i, (k, v) in enumerate(feats_generator): enr.append(v) enrid2ind[k] = i enr = np.array(enr) tstid2ind = {} tst = [] feat_rsp = "ark:{}/{}.test.ark".format(data_dir, c) feats_generator = kaldi_io.read_vec_flt_ark(feat_rsp) for i, (k, v) in enumerate(feats_generator): tst.append(v) tstid2ind[k] = i tst = np.array(tst) print(tst.shape) if (mean_set != "None"): enr -= mean_vec tst -= mean_vec #coh -= mean_vec # L-norm enr /= np.sqrt(np.sum(enr**2, axis=1, keepdims=True)) / np.sqrt(256) tst /= np.sqrt(np.sum(tst**2, axis=1, keepdims=True)) / np.sqrt(256) #coh /= np.sum(coh**2, axis=1, keepdims=True) / np.sqrt(256) e_scr = -np.sort(-np.matmul(enr, coh.T), axis=1) # The minus signs is to get descending sort t_scr = -np.sort(-np.matmul(tst, coh.T), axis=1) # if not os.path.exists(out_dir): # os.makedirs(out_dir) # #np.savetxt(out_dir + "/scores_" + c + "_enroll_cohort", e_scr) # #np.savetxt(out_dir + "/scores_" + c + "_test_cohort", t_scr) #if not os.path.exists("{}/cohort_{}/".format(out_dir, cohort_sizes[4])): # os.makedirs( "{}/cohort_{}/".format(out_dir, cohort_sizes[4]) ) #print("Saving test-cohort scores") #print("Saving enroll-cohort scores") #np.save(out_dir + "/scores_" + c + "_test_cohort.npy", t_scr) #np.save(out_dir + "/scores_" + c + "_enroll_cohort.npy", e_scr) #continue # Calculate the means and standard deviations we want to use e_mean = [np.mean(e_scr[:, 0:s], axis=1) for s in cohort_sizes] e_std = [np.std(e_scr[:, 0:s], axis=1) for s in cohort_sizes] t_mean = [np.mean(t_scr[:, 0:s], axis=1) for s in cohort_sizes] t_std = [np.std(t_scr[:, 0:s], axis=1) for s in cohort_sizes] scr = [] scr_as = [[] for i in range(len(cohort_sizes))] lab = [] n = 0 n_succeed = 0 e_name = [] t_name = [] with open("{}/{}.trial".format(trial_list_dir, c)) as f: line = (f.readline()).rstrip() while line: n += 1 e, t, l = line.split(" ") e_name.append(e) t_name.append(t) if (e in enrid2ind and t in tstid2ind): n_succeed += 1 e_v = enr[enrid2ind[e]] t_v = tst[tstid2ind[t]] s = np.dot(e_v, t_v) scr.append(s) for i in range(len(cohort_sizes)): try: scr_as[i].append(0.5 * ((s - e_mean[i][enrid2ind[e]]) / e_std[i][enrid2ind[e]] + (s - t_mean[i][tstid2ind[t]]) / t_std[i][tstid2ind[t]])) except: print("ERROR") sys.exit() lab.append(l) line = (f.readline()).rstrip() assert (len(scr_as[i]) == len(e_name) == len(t_name)) if not os.path.exists("{}/cohort_{}/".format(out_dir, cohort_sizes[4])): os.makedirs("{}/cohort_{}/".format(out_dir, cohort_sizes[4])) with open("{}/cohort_{}/scores_{}".format(out_dir, cohort_sizes[4], c), "w") as f_s: print("Saving scores of {} cohort size {}".format( c, cohort_sizes[4])) for j in range(len(e_name)): f_s.write("{} {} {}\n".format(e_name[j], t_name[j], scr_as[4][j])) eer = check_eer_with_kaldi(scr, lab) if (eer != "-"): lab_01 = [1 if l == "target" else 0 for l in lab] fnrs, fprs, thresholds = ComputeErrorRates(scr, lab_01) p_target, c_miss, c_fa = 0.05, 1, 1 mindcf05, threshold = ComputeMinDcf(fnrs, fprs, thresholds, p_target=p_target, c_miss=c_miss, c_fa=c_fa) p_target, c_miss, c_fa = 0.01, 1, 1 mindcf01, threshold = ComputeMinDcf(fnrs, fprs, thresholds, p_target=p_target, c_miss=c_miss, c_fa=c_fa) p_target, c_miss, c_fa = 0.001, 1, 1 mindcf001, threshold = ComputeMinDcf(fnrs, fprs, thresholds, p_target=p_target, c_miss=c_miss, c_fa=c_fa) print( "No norm #trials {}/{} EER {}, minDCF0.05 {:.4f}, minDCF0.01 {:.4f}, minDCF0.001 {:.4f}" .format(n_succeed, n, eer, mindcf05, mindcf01, mindcf001)) else: print( "As-norm-{} #trials {}/{} EER -, minDCF0.05 -, minDCF0.01 -, minDCF0.001 -" .format(cohort_sizes[i], n_succeed, n)) for i in range(len(cohort_sizes)): eer = check_eer_with_kaldi(scr_as[i], lab) if (eer != "-"): fnrs, fprs, thresholds = ComputeErrorRates(scr_as[i], lab_01) p_target, c_miss, c_fa = 0.05, 1, 1 mindcf05, threshold = ComputeMinDcf(fnrs, fprs, thresholds, p_target=p_target, c_miss=c_miss, c_fa=c_fa) p_target, c_miss, c_fa = 0.01, 1, 1 mindcf01, threshold = ComputeMinDcf(fnrs, fprs, thresholds, p_target=p_target, c_miss=c_miss, c_fa=c_fa) p_target, c_miss, c_fa = 0.001, 1, 1 mindcf001, threshold = ComputeMinDcf(fnrs, fprs, thresholds, p_target=p_target, c_miss=c_miss, c_fa=c_fa) print( "As-norm-{} #trials {}/{} EER {}, minDCF0.05 {:.4f}, minDCF0.01 {:.4f}, minDCF0.001 {:.4f}" .format(cohort_sizes[i], n_succeed, n, eer, mindcf05, mindcf01, mindcf001)) else: print( "As-norm-{} #trials {}/{} EER -, minDCF0.05 -, minDCF0.01 -, minDCF0.001 -" .format(cohort_sizes[i], n_succeed, n))
phone_map = read_inv_phone_map(args.phone_map) correct_means = [[] for _ in range(len(phone_map))] correct_stds = [[] for _ in range(len(phone_map))] correct_ranges = [[] for _ in range(len(phone_map))] misp_means = [[] for _ in range(len(phone_map))] misp_stds = [[] for _ in range(len(phone_map))] misp_ranges = [[] for _ in range(len(phone_map))] flags_dict = {k: v for k, v in kio.read_vec_int_ark(args.flags)} # Create dictionaries with scores score_dicts = [] for eval_dir in args.eval_dirs: score_file = os.path.join(eval_dir, 'score.ark') score_dict = {k: v for k, v in kio.read_vec_flt_ark(score_file)} score_dicts.append(score_dict) # Iterate through all the texts for key, phones in kio.read_vec_int_ark(args.text): # Workaround: Skip unscored utterances if key not in score_dicts[0]: continue scores_list = [] for score_dict in score_dicts: scores_list.append(score_dict[key]) flags = flags_dict[key] for i in range(len(phones)): # Calculate mean and std
W = alpha * W_train + (1.0 - alpha) * W_adapt B = alpha * B_train + (1.0 - alpha) * B_adapt acvar, wccn = spl.eigh(B, W) plda_psi = acvar[::-1] plda_tr = wccn.T[::-1] # Prepare model for VB-HMM clustering (see the comment on "fea" variable below) ubmWeights = np.array([1.0]) ubmMeans = np.zeros((1, lda_dim)) invSigma = np.ones((1, lda_dim)) V = np.diag(np.sqrt(plda_psi[:lda_dim]))[:, np.newaxis, :] VtinvSigmaV = VB_diarization.precalculate_VtinvSigmaV(V, invSigma) # Open ark file with x-vectors and in each iteration of the following for-loop # read a batch of x-vectors corresponding to one recording arkit = kaldi_io.read_vec_flt_ark(xvec_ark_file) recit = itertools.groupby(arkit, lambda e: e[0].rsplit('_', 1)[0] ) # group xvectors in ark by recording name for file_name, segs in recit: print(file_name) seg_names, xvecs = zip(*segs) x = np.array( xvecs ) # matrix of all x-vectors corresponding to recording "file_name" #hac_start = time.time() # Kaldi-like global norm and lenth-norm x = (x - glob_mean).dot(glob_tran.T) x *= np.sqrt(x.shape[1] / (x**2).sum(axis=1)[:, np.newaxis])