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])
