def test_process_features_online_with_frame_hop_size_change_stores_correct(self, processor, tmpdir):
ds = resources.create_dataset()
in_feat_path = os.path.join(tmpdir.strpath, 'in_feats')
out_feat_path = os.path.join(tmpdir.strpath, 'out_feats')
in_feats = containers.FeatureContainer(in_feat_path)
utt_feats = np.arange(30).reshape(5, 6)
with in_feats:
in_feats.sampling_rate = 16000
in_feats.frame_size = 400
in_feats.hop_size = 160
for utt_idx in ds.utterances.keys():
in_feats.set(utt_idx, utt_feats)
processor.mock_frame_size_scale = 2.0
processor.mock_hop_size_scale = 2.0
processor.process_features_online(ds, in_feats, out_feat_path)
out_feats = containers.FeatureContainer(out_feat_path)
with out_feats:
assert out_feats.frame_size == 800
assert out_feats.hop_size == 320
def test_process_features(self, processor, tmpdir):
ds = resources.create_dataset()
in_feat_path = os.path.join(tmpdir.strpath, 'in_feats')
out_feat_path = os.path.join(tmpdir.strpath, 'out_feats')
in_feats = containers.FeatureContainer(in_feat_path)
utt_feats = np.arange(30).reshape(5, 6)
with in_feats:
in_feats.sampling_rate = 16000
in_feats.frame_size = 400
in_feats.hop_size = 160
for utt_idx in ds.utterances.keys():
in_feats.set(utt_idx, utt_feats)
processor.process_features(ds, in_feats, out_feat_path)
out_feats = containers.FeatureContainer(out_feat_path)
with out_feats:
assert len(out_feats.keys()) == 5
assert np.array_equal(out_feats.get('utt-1', mem_map=False), utt_feats)
assert np.array_equal(out_feats.get('utt-2', mem_map=False), utt_feats)
assert np.array_equal(out_feats.get('utt-3', mem_map=False), utt_feats)
assert np.array_equal(out_feats.get('utt-4', mem_map=False), utt_feats)
assert np.array_equal(out_feats.get('utt-5', mem_map=False), utt_feats)
def test_process_features_online_with_given_chunk_size(self, processor, tmpdir):
ds = resources.create_dataset()
in_feat_path = os.path.join(tmpdir.strpath, 'in_feats')
out_feat_path = os.path.join(tmpdir.strpath, 'out_feats')
in_feats = containers.FeatureContainer(in_feat_path)
utt_feats = np.arange(90).reshape(15, 6)
with in_feats:
in_feats.sampling_rate = 16000
in_feats.frame_size = 400
in_feats.hop_size = 160
for utt_idx in ds.utterances.keys():
in_feats.set(utt_idx, utt_feats)
processor.process_features_online(ds, in_feats, out_feat_path, chunk_size=4)
out_feats = containers.FeatureContainer(out_feat_path)
assert len(processor.called_with_data) == 4 * 5
assert processor.called_with_data[0].shape == (4, 6)
assert processor.called_with_data[3].shape == (3, 6)
with out_feats:
assert len(out_feats.keys()) == 5
assert np.array_equal(out_feats.get('utt-1', mem_map=False), utt_feats)
assert np.array_equal(out_feats.get('utt-2', mem_map=False), utt_feats)
assert np.array_equal(out_feats.get('utt-3', mem_map=False), utt_feats)
assert np.array_equal(out_feats.get('utt-4', mem_map=False), utt_feats)
assert np.array_equal(out_feats.get('utt-5', mem_map=False), utt_feats)
def new_feature_container(self, idx, path=None):
"""
Add a new feature container with the given data.
Parameters:
idx (str): An unique identifier within the dataset.
path (str): The path to store the feature file. If None a default path is used.
Returns:
FeatureContainer: The newly added feature-container.
"""
new_feature_idx = idx
new_feature_path = path
# Add index to idx if already existing
if new_feature_idx in self._feature_containers.keys():
new_feature_idx = naming.index_name_if_in_list(
new_feature_idx, self._feature_containers.keys())
# Set default path if none given
if new_feature_path is None:
if not os.path.isdir(self.path):
raise ValueError(
'To copy file the dataset needs to have a path.')
new_feature_path = os.path.join(self.path, DEFAULT_FEAT_SUBDIR,
new_feature_idx)
else:
new_feature_path = os.path.abspath(new_feature_path)
feat_container = containers.FeatureContainer(new_feature_path)
self._feature_containers[new_feature_idx] = feat_container
return feat_container
def test_process_features_online_ignores_none(self, processor, tmpdir):
ds = resources.create_dataset()
in_feat_path = os.path.join(tmpdir.strpath, 'in_feats')
out_feat_path = os.path.join(tmpdir.strpath, 'out_feats')
in_feats = containers.FeatureContainer(in_feat_path)
utt_feats = np.arange(90).reshape(15, 6)
with in_feats:
in_feats.sampling_rate = 16000
in_feats.frame_size = 400
in_feats.hop_size = 160
for utt_idx in ds.utterances:
in_feats.set(utt_idx, utt_feats)
def return_none(*args, **kwargs):
return None
processor.process_frames = return_none
processor.process_features_online(ds,
in_feats,
out_feat_path,
chunk_size=4)
assert True
def _process_corpus(self,
corpus,
output_path,
processing_func,
frame_size=400,
hop_size=160,
sr=None):
""" Utility function for processing a corpus with a separate processing function. """
feat_container = containers.FeatureContainer(output_path)
feat_container.open()
sampling_rate = -1
for utterance in corpus.utterances.values():
utt_sampling_rate = utterance.sampling_rate
if sr is None:
if sampling_rate > 0 and sampling_rate != utt_sampling_rate:
raise ValueError(
'File {} has a different sampling-rate than the previous ones!'
.format(utterance.track.idx))
sampling_rate = utt_sampling_rate
processing_func(utterance, feat_container, frame_size, hop_size,
sr, corpus)
tf_frame_size, tf_hop_size = self.frame_transform(frame_size, hop_size)
feat_container.frame_size = tf_frame_size
feat_container.hop_size = tf_hop_size
feat_container.sampling_rate = sr or sampling_rate
feat_container.close()
return feat_container
def sample_feature_container():
container_path = resources.get_resource_path(
['sample_files', 'feat_container']
)
sample_container = containers.FeatureContainer(container_path)
sample_container.open()
yield sample_container
sample_container.close()
def process_features_online(self,
corpus,
input_features,
output_path,
chunk_size=1):
"""
Process all features of the given corpus and save the processed features in a feature-container.
The features are processed in **online** mode, chunk by chunk.
Args:
corpus (Corpus): The corpus to process the utterances from.
input_features (FeatureContainer): The feature-container to process the frames from.
output_path (str): A path to save the feature-container to.
chunk_size (int): Number of frames to process per chunk.
Returns:
FeatureContainer: The feature-container containing the processed features.
"""
feat_container = containers.FeatureContainer(output_path)
feat_container.open()
input_features.open()
for utterance in corpus.utterances.values():
sampling_rate = input_features.sampling_rate
frames = input_features.get(utterance.idx, mem_map=True)
current_frame = 0
while current_frame < frames.shape[0]:
last = current_frame + chunk_size > frames.shape[0]
to_frame = current_frame + chunk_size
chunk = frames[current_frame:to_frame]
processed = self.process_frames(chunk,
sampling_rate,
current_frame,
last=last,
utterance=utterance,
corpus=corpus)
if processed is not None:
feat_container.append(utterance.idx, processed)
current_frame += chunk_size
tf_frame_size, tf_hop_size = self.frame_transform(
input_features.frame_size, input_features.hop_size)
feat_container.frame_size = tf_frame_size
feat_container.hop_size = tf_hop_size
feat_container.sampling_rate = input_features.sampling_rate
feat_container.close()
return feat_container
def test_process_corpus_online_with_frame_hop_size_change_stores_correct(self, processor, tmpdir):
ds = resources.create_dataset()
feat_path = os.path.join(tmpdir.strpath, 'feats')
processor.mock_frame_size_scale = 0.5
processor.mock_hop_size_scale = 0.25
processor.process_corpus_online(ds, feat_path, frame_size=4096, hop_size=2048)
fc = containers.FeatureContainer(feat_path)
fc.open()
assert fc.frame_size == 2048
assert fc.hop_size == 512
fc.close()
def container_dim_x_4(tmpdir):
inputs_path = os.path.join(tmpdir.strpath, 'inputs.hdf5')
cnt = containers.FeatureContainer(inputs_path)
cnt.open()
cnt.frame_size = 4
cnt.hop_size = 2
cnt.sampling_rate = 16000
cnt.set('utt-1', np.arange(60).reshape(15, 4))
cnt.set('utt-2', np.arange(80).reshape(20, 4))
cnt.set('utt-3', np.arange(44).reshape(11, 4))
cnt.set('utt-4', np.arange(12).reshape(3, 4))
cnt.set('utt-5', np.arange(16).reshape(4, 4))
return cnt
def process_features(self, corpus, input_features, output_path):
"""
Process all features of the given corpus and save the processed features in a feature-container.
The features are processed in **offline** mode, all features of an utterance at once.
Args:
corpus (Corpus): The corpus to process the utterances from.
input_features (FeatureContainer): The feature-container to process the frames from.
output_path (str): A path to save the feature-container to.
Returns:
FeatureContainer: The feature-container containing the processed features.
"""
feat_container = containers.FeatureContainer(output_path)
feat_container.open()
input_features.open()
for utterance in corpus.utterances.values():
sampling_rate = input_features.sampling_rate
frames = input_features.get(utterance.idx, mem_map=False)
processed = self.process_frames(frames,
sampling_rate,
offset=0,
last=True,
utterance=utterance,
corpus=corpus)
feat_container.set(utterance.idx, processed)
tf_frame_size, tf_hop_size = self.frame_transform(
input_features.frame_size, input_features.hop_size)
feat_container.frame_size = tf_frame_size
feat_container.hop_size = tf_hop_size
feat_container.sampling_rate = input_features.sampling_rate
feat_container.close()
return feat_container
