def run(self, d, binary=True):
#Execute Kaldi command inputting dict d and return KaldiFormat handler
ark_in = KaldiArk('/tmp/pipe.ark', 'wb')
for key, mat in d:
ark_in.write(key, mat)
ark_in.p.close()
return self.run_file('/tmp/pipe.ark', binary)
def run(self, d, binary=True):
#Execute Kaldi command inputting dict d and return KaldiFormat handler
ark_in = KaldiArk('/tmp/pipe.ark','wb')
for key, mat in d:
ark_in.write(key, mat)
ark_in.p.close()
return self.run_file('/tmp/pipe.ark', binary)
def load_timit_labeled_posterior(post_file, pdf_ark):
"""
Load the TIMIT frames with their labels from .scp file.
Each frame is concatinated with its neighbor frames
(e.x. offsets=[-2,-1,0,1,2] then each frame is concatenated with +-2 frames
and generating dim*5 dimensional vectors).
If ratio is less than 1, some labels will be removed for semi-supervised experiment.
The ratio determines the ratio of labeled data to whole data (unlabeled + labeled).
In this time, the minimum number of samples in each class will be min_count.
If foldings_file is given, some phones are folded into specific phone.
Return: feature matrix,
"""
feats = KaldiCommand(
'featbin/apply-cmvn',
option='--norm-means=true --norm-vars=true --utt2spk=ark:' +
feats_dir + '/utt2spk scp:' + feats_dir + '/cmvn.scp')
train_x, train_y = load_labeled_data(feats << feats_dir + '/feats.scp',
KaldiArk(pdf_ark), offsets, bias,
scale)
# if word_to_i is None:
# word_to_i = __get_word_to_i__(train_labels)
# Convert labels to word IDs
# train_y = np.asarray([word_to_i[label] for label in train_labels],dtype=np.int32)
return train_x, train_y
def load_timit_labelled_kaldi(feats_dir,
pdf_dir=None,
offsets=[0],
nnet_transf=None,
bias=None,
scale=None,
cmvn=None,
folding=True):
"""
Load the TIMIT frames with their labels from directory
Each frame is concatinated with its neighbor frames as described in nnet_transf.
When pdf_dir is given, this function returns:
feature matrix, labels
Otherwise, this function returns
feature matrix, {utt_id: (s_frame, e_frame)}
"""
if nnet_transf is not None:
for layer in load_nnet(nnet_transf):
if layer['func'] == 'Splice':
offsets = layer['context']
elif layer['func'] == 'AddShift':
bias = layer['b']
elif layer['func'] == 'Rescale':
scale = layer['b']
assert cmvn == None or 'global' or 'utterance' or 'speaker', 'Unknown cmvn option: %s' % cmvn
if cmvn is not None:
if cmvn == 'global':
feats = apply_cmvn(feats_dir + '/feats.scp',
utt2spk='global',
var_norm=True)
elif cmvn == 'utterance':
feats = apply_cmvn(feats_dir + '/feats.scp', var_norm=True)
elif cmvn == 'speaker':
feats = apply_cmvn(feats_dir + '/feats.scp',
utt2spk=feats_dir + '/utt2spk',
var_norm=True)
else:
logger.error('Unknown cmvn option: %s' % cmvn)
else:
feats = {key: v for key, v in KaldiScp(feats_dir + '/feats.scp')}
if pdf_dir is not None:
train_x, train_y = \
load_labeled_data(feats, KaldiArk(pdf_dir), offsets, bias, scale, folding=True)
else:
train_x, train_y = \
load_data(feats, offsets, bias, scale, folding=True)
return train_x, train_y
def load_labeled_data_kaldi(dirname):
feats = {key: value for key, value in KaldiScp(dirname + '/feats.scp')}
pdf = {key: value for key, value in KaldiArk(dirname + '/ali.ark')}
return load_labeled_data(feats, pdf)
def rspecifier(filename):
if os.path.splitext(filename)[-1] == ".ark":
return KaldiArk(filename)
elif os.path.splitext(filename)[-1] == ".scp":
return KaldiScp(filename)
def load_timit_labelled_kaldi_KaldiCommand(feats_dir,
pdf_dir=None,
offsets=[0],
nnet_transf=None,
bias=None,
scale=None,
cmvn=False,
folding=True):
"""
Load the TIMIT frames with their labels from directory
Each frame is concatinated with its neighbor frames as described in nnet_transf.
When pdf_dir is given, this function returns:
feature matrix, labels
Otherwise, this function returns
feature matrix, {utt_id: (s_frame, e_frame)}
"""
def load_labeled_data(ark,
pdf,
offsets=[0],
bias=None,
scale=None,
folding=True):
X = []
labels = []
ali = {key: vec for key, vec in pdf}
for key, data in ark:
labels.append(ali[key])
for x in splice(data, offsets, folding):
if bias is not None:
x += bias[0]
if scale is not None:
x *= scale[0]
X.append(x)
return np.vstack(X), np.hstack(labels)
if nnet_transf is not None:
for layer in load_nnet(nnet_transf):
if layer['func'] == 'Splice':
offsets = layer['context']
elif layer['func'] == 'AddShift':
bias = layer['b']
elif layer['func'] == 'Rescale':
scale = layer['b']
if cmvn:
logger.info("Applying CMVN: %s" % (feats_dir + '/cmvn.scp'))
assert os.path.exists(feats_dir +
'/cmvn.scp'), 'cmvn file is not found: %s' % (
feats_dir + '/cmvn.scp')
feats = KaldiCommand(
'featbin/apply-cmvn',
option='--norm-means=true --norm-vars=true --utt2spk=ark:' +
feats_dir + '/utt2spk scp:' + feats_dir + '/cmvn.scp')
else:
feats = KaldiCommand('featbin/copy-feats')
if pdf_dir is not None:
train_x, train_y = load_labeled_data(feats << feats_dir + '/feats.scp',
KaldiArk(pdf_dir),
offsets,
bias,
scale,
folding=True)
else:
train_x, train_y = load_data(feats << feats_dir + '/feats.scp',
offsets,
bias,
scale,
folding=True)
return train_x, train_y
#from scipy.spatial import KDTree
from kaldi.io import KaldiArk
from sklearn.neighbors import KDTree
import numpy as np
if __name__ -- "__main__":
in_filename=sys.argv[0]
out_filename=sys.argv[0]
ark = KaldiArk(in_file)
print "Reading from" + in_filename
d1={key: m for key,m in ark}
print "Read " + str(len(d1)) " keys."
N=60000
x_train, x_test = np.split(mnist['data'], [N])
y_train, y_test = np.split(mnist['target'], [N])
kdt = KDTree(x_train, leaf_size=30,metric='euclidean')
res = kdt.query(x_test, k=10)
analyze_cmd.add_argument("--dataset", type=str, default='/home-nfs/tawara/work/ttic/MyPython/src/timit/timit_3.test.npz',
help="Which dataset to use")
rng = numpy.random.RandomState(1)
args = ap.parse_args()
t_start = time.time()
if args.cmd == 'analyze':
batchsize = args.batchsize
filename = args.load_from
print "load from %s" % filename
model = pickle.load(open(filename,'rb'))
model.device_id = [0]
cuda.get_device(0).use()
offset = range(-context_length, context_length+1)
x_test, frame_index = load_timit_labelled_kaldi(\
KaldiArk('/data2/tawara/work/ttic/MyPython/src/kaldi/timit/feats_test_cmvn.ark'), \
nnet_transf = '/data2/tawara/work/ttic/MyPython/src/kaldi/timit/final.feature_transform')
x_train,_ = load_data(\
KaldiScp('/data2/tawara/work/ttic/MyPython/src/kaldi/timit/data/fbank/train_tr90/feats.scp'), \
offsets = offset)
N_test=x_test.shape[0]
N_train=x_train.shape[0]
print "Applying batch normalization"
for i in xrange(0, N_train, batchsize):
x_batch = x_train[i : i + batchsize]
model.forward(x_batch,test=False)
logger.info("Extracting final layer")
save_to = args.save_to
print 'Saving output layer to %s' % filename+'.post.ark'
ark=KaldiArk(filename+'.post.ark','wb')
