def test_has_correct_shape(self):
sr = SR22050()
samples = SilenceSynthesizer(sr).synthesize(Milliseconds(9999))
wscheme = sr.windowing_scheme(256, 128)
scale = GeometricScale(50, sr.nyquist, 0.4, 32)
scale.ensure_overlap_ratio()
tf = stft(samples, wscheme, HanningWindowingFunc())
geom = apply_scale(tf, scale, window=HanningWindowingFunc())
self.assertEqual(tf.shape[:-1] + (len(scale),), geom.shape)
def test_has_correct_shape(self):
sr = SR22050()
samples = SilenceSynthesizer(sr).synthesize(Milliseconds(9999))
wscheme = sr.windowing_scheme(256, 128)
scale = GeometricScale(50, sr.nyquist, 0.4, 32)
scale.ensure_overlap_ratio()
tf = stft(samples, wscheme, HanningWindowingFunc())
geom = apply_scale(tf, scale, window=HanningWindowingFunc())
self.assertEqual(tf.shape[:-1] + (len(scale), ), geom.shape)
def test_has_correct_dimensions(self):
samplerate = SR22050()
scale = GeometricScale(start_center_hz=20,
stop_center_hz=10000,
bandwidth_ratio=0.2,
n_bands=100)
scale.ensure_overlap_ratio(0.5)
taps = 256
filter_bank = fir_filter_bank(scale, taps, samplerate, np.hanning(100))
self.assertEqual((len(scale), taps), filter_bank.shape)
self.assertEqual(FrequencyDimension(scale), filter_bank.dimensions[0])
self.assertEqual(TimeDimension(*samplerate), filter_bank.dimensions[1])
def test_smoke(self):
samples = AudioSamples.silence(SR22050(), Seconds(1))
samplerate = SR22050()
scale = GeometricScale(start_center_hz=20,
stop_center_hz=5000,
bandwidth_ratio=1.2,
n_bands=8)
scale.ensure_overlap_ratio(0.5)
taps = 16
filter_bank = fir_filter_bank(scale, taps, samplerate, np.hanning(3))
correlogram = auto_correlogram(samples, filter_bank)
self.assertEqual(3, correlogram.ndim)
def test_smoke(self):
samples = AudioSamples.silence(SR22050(), Seconds(1))
samplerate = SR22050()
scale = GeometricScale(
start_center_hz=20,
stop_center_hz=5000,
bandwidth_ratio=1.2,
n_bands=8)
scale.ensure_overlap_ratio(0.5)
taps = 16
filter_bank = fir_filter_bank(scale, taps, samplerate, np.hanning(3))
correlogram = auto_correlogram(samples, filter_bank)
self.assertEqual(3, correlogram.ndim)
def test_has_correct_dimensions(self):
samplerate = SR22050()
scale = GeometricScale(
start_center_hz=20,
stop_center_hz=10000,
bandwidth_ratio=0.2,
n_bands=100)
scale.ensure_overlap_ratio(0.5)
taps = 256
filter_bank = fir_filter_bank(scale, taps, samplerate, np.hanning(100))
self.assertEqual((len(scale), taps), filter_bank.shape)
self.assertEqual(FrequencyDimension(scale), filter_bank.dimensions[0])
self.assertEqual(TimeDimension(*samplerate), filter_bank.dimensions[1])
def test_has_correct_dimensions(self):
sr = SR22050()
samples = SilenceSynthesizer(sr).synthesize(Milliseconds(9999))
wscheme = sr.windowing_scheme(256, 128)
scale = GeometricScale(50, sr.nyquist, 0.4, 32)
scale.ensure_overlap_ratio()
tf = stft(samples, wscheme, HanningWindowingFunc())
geom = apply_scale(tf, scale, window=HanningWindowingFunc())
self.assertIsInstance(geom, ArrayWithUnits)
self.assertEqual(2, len(geom.dimensions))
self.assertIsInstance(geom.dimensions[0], TimeDimension)
self.assertEqual(geom.dimensions[0].samplerate, wscheme)
self.assertIsInstance(geom.dimensions[1], FrequencyDimension)
self.assertEqual(scale, geom.dimensions[1].scale)
def test_has_correct_dimensions(self):
sr = SR22050()
samples = SilenceSynthesizer(sr).synthesize(Milliseconds(9999))
wscheme = sr.windowing_scheme(256, 128)
scale = GeometricScale(50, sr.nyquist, 0.4, 32)
scale.ensure_overlap_ratio()
tf = stft(samples, wscheme, HanningWindowingFunc())
geom = apply_scale(tf, scale, window=HanningWindowingFunc())
self.assertIsInstance(geom, ArrayWithUnits)
self.assertEqual(2, len(geom.dimensions))
self.assertIsInstance(geom.dimensions[0], TimeDimension)
self.assertEqual(geom.dimensions[0].samplerate, wscheme)
self.assertIsInstance(geom.dimensions[1], FrequencyDimension)
self.assertEqual(scale, geom.dimensions[1].scale)
def test_can_invert_pipeline_that_takes_frequency_adaptive_transform(self):
td = TimeDimension(frequency=Seconds(1))
scale = GeometricScale(20, 5000, 0.05, 10)
arrs = [np.zeros((10, x)) for x in range(1, 11)]
fa = FrequencyAdaptive(arrs, td, scale)
@simple_in_memory_settings
class Model(featureflow.BaseModel):
log = featureflow.PickleFeature(
Log,
store=False)
meanstd = featureflow.PickleFeature(
MeanStdNormalization,
needs=log,
store=False)
pipeline = featureflow.PickleFeature(
PreprocessingPipeline,
needs=(log, meanstd),
store=True)
_id = Model.process(log=fa)
model = Model(_id)
result = model.pipeline.transform(fa)
recon = result.inverse_transform()
self.assertIsInstance(recon, FrequencyAdaptive)
self.assertEqual(fa.shape, recon.shape)
def test_can_access_single_frequency_band(self):
td = TimeDimension(duration=Seconds(1), frequency=Milliseconds(500))
scale = GeometricScale(20, 5000, 0.05, 120)
arrs = [np.zeros((10, x)) for x in xrange(1, 121)]
fa = FrequencyAdaptive(arrs, td, scale)
sliced = fa[:, scale[0]]
self.assertEqual((10, 1), sliced.shape)
def test_can_compute_frequency_adaptive_feature(self):
scale = GeometricScale(
start_center_hz=50,
stop_center_hz=5000,
bandwidth_ratio=0.07123,
n_bands=128)
fa = frequency_adaptive(
SampleRate(frequency=Milliseconds(358), duration=Milliseconds(716)),
scale,
store_freq_adaptive=True)
@simple_in_memory_settings
class Document(fa):
rasterized = ArrayWithUnitsFeature(
lambda fa: fa.rasterize(64).astype(np.float32),
needs=fa.freq_adaptive,
store=True)
synth = SineSynthesizer(SR22050())
samples = synth.synthesize(Seconds(10))
_id = Document.process(meta=samples.encode())
doc = Document(_id)
self.assertIsInstance(doc.freq_adaptive, FrequencyAdaptive)
self.assertEqual((64, 128), doc.rasterized.shape[-2:])
def test_can_round_trip_geometric_scale(self):
scale = GeometricScale(20, 5000, bandwidth_ratio=0.01, n_bands=100)
dim = FrequencyDimension(scale)
encoded = self.encoder.encode(dim)
decoded = self.decoder.decode(encoded)
self.assertIsInstance(decoded.scale, GeometricScale)
self.assertEqual(scale, decoded.scale)
def test_can_round_trip_explicit_scale(self):
scale = ExplicitScale(GeometricScale(20, 5000, 0.05, n_bands=100))
encoder_decoder = ExplicitScaleEncoderDecoder()
self.assertTrue(encoder_decoder.can_encode(scale))
encoded = encoder_decoder.encode(scale)
self.assertTrue(encoder_decoder.can_decode(encoded))
decoded = encoder_decoder.decode(encoded)
self.assertEqual(scale, decoded)
def test_can_roundtrip_frequency_adaptive_transform(self):
td = TimeDimension(duration=Seconds(1), frequency=Milliseconds(500))
scale = GeometricScale(20, 5000, 0.05, 120)
arrs = [np.zeros((10, x)) for x in range(1, 121)]
fa = FrequencyAdaptive(arrs, td, scale)
decoded = self._roundtrip(fa, decoder=FrequencyAdaptiveDecoder())
self.assertIsInstance(decoded, FrequencyAdaptive)
self.assertEqual(fa.dimensions, decoded.dimensions)
def test_can_round_trip(self):
scale = GeometricScale(20, 5000, 0.05, 3)
slices = [slice(0, 10), slice(10, 100), slice(100, 1000)]
dim = ExplicitFrequencyDimension(scale, slices)
encoded = self.encoder.encode(dim)
decoded = self.decoder.decode(encoded)
self.assertIsInstance(decoded, ExplicitFrequencyDimension)
self.assertEqual(dim, decoded)
def test_can_construct_instance(self):
td = TimeDimension(frequency=Seconds(1))
scale = GeometricScale(20, 5000, 0.05, 10)
arrs = [np.zeros((10, x)) for x in xrange(1, 11)]
fa = FrequencyAdaptive(arrs, td, scale)
self.assertEqual((10, 55), fa.shape)
self.assertIsInstance(fa.dimensions[0], TimeDimension)
self.assertIsInstance(fa.dimensions[1], ExplicitFrequencyDimension)
def test_can_assign_to_multi_band_frequency_slice(self):
td = TimeDimension(frequency=Seconds(1))
scale = GeometricScale(20, 5000, 0.05, 10)
arrs = [np.zeros((10, x)) for x in xrange(1, 11)]
fa = FrequencyAdaptive(arrs, td, scale)
band = FrequencyBand(300, 3030)
fa[:, band] = 1
int_slice = fa.dimensions[1].integer_based_slice(band)
np.testing.assert_allclose(fa[:, int_slice], 1)
def test_preserves_time_dimension(self):
sr = SR22050()
samples = TickSynthesizer(sr).synthesize(
Milliseconds(10000), Milliseconds(1000))
wscheme = sr.windowing_scheme(256, 128)
scale = GeometricScale(50, sr.nyquist, 0.4, 32)
scale.ensure_overlap_ratio()
tf = stft(samples, wscheme, HanningWindowingFunc())
geom = apply_scale(tf, scale, window=HanningWindowingFunc())
# get the loudness envelope of each
tf_envelope = np.abs(tf.real).sum(axis=1)
geom_envelope = geom.sum(axis=1)
tf_zeros = np.where(tf_envelope == 0)
geom_zeros = np.where(geom_envelope == 0)
np.testing.assert_allclose(tf_zeros, geom_zeros)
def test_preserves_time_dimension(self):
sr = SR22050()
samples = TickSynthesizer(sr).synthesize(Milliseconds(10000),
Milliseconds(1000))
wscheme = sr.windowing_scheme(256, 128)
scale = GeometricScale(50, sr.nyquist, 0.4, 32)
scale.ensure_overlap_ratio()
tf = stft(samples, wscheme, HanningWindowingFunc())
geom = apply_scale(tf, scale, window=HanningWindowingFunc())
# get the loudness envelope of each
tf_envelope = np.abs(tf.real).sum(axis=1)
geom_envelope = geom.sum(axis=1)
tf_zeros = np.where(tf_envelope == 0)
geom_zeros = np.where(geom_envelope == 0)
np.testing.assert_allclose(tf_zeros, geom_zeros)
def test_can_apply_weighting(self):
@simple_in_memory_settings
class Model(ff.BaseModel):
weighted = ff.PickleFeature(
Weighted,
weighting=AWeighting(),
store=False)
scaled = ff.PickleFeature(
InstanceScaling,
needs=weighted,
store=False)
pipeline = ff.PickleFeature(
PreprocessingPipeline,
needs=(weighted, scaled),
store=True)
training = ArrayWithUnits(
np.random.random_sample((100, 15)),
dimensions=[
TimeDimension(Seconds(1)),
FrequencyDimension(GeometricScale(100, 1000, 0.1, 15))
]
)
_id = Model.process(weighted=training)
model = Model(_id)
test = ArrayWithUnits(
np.random.random_sample((10, 15)),
dimensions=[
TimeDimension(Seconds(1)),
FrequencyDimension(GeometricScale(100, 1000, 0.1, 15))
]
)
result = model.pipeline.transform(test)
inverted = result.inverse_transform()
np.testing.assert_allclose(test, inverted)
def test_can_construct_from_contiguous_array(self):
td = TimeDimension(frequency=Seconds(1))
scale = GeometricScale(20, 5000, 0.05, 10)
arrs = [np.zeros((10, x)) for x in xrange(1, 11)]
fa1 = FrequencyAdaptive(arrs, td, scale)
arr = np.asarray(fa1)
fa2 = FrequencyAdaptive(
arr, td, explicit_freq_dimension=fa1.frequency_dimension)
self.assertEqual(fa1.shape, fa2.shape)
self.assertEqual(fa1.scale, fa2.scale)
self.assertEqual(fa1.time_dimension, fa2.time_dimension)
self.assertEqual(fa1.frequency_dimension, fa2.frequency_dimension)
def test_can_concatenate_instances(self):
td = TimeDimension(frequency=Seconds(1))
scale = GeometricScale(20, 5000, 0.05, 10)
arrs = [np.zeros((10, x)) for x in xrange(1, 11)]
fa = FrequencyAdaptive(arrs, td, scale)
arrs2 = [np.zeros((20, x)) for x in xrange(1, 11)]
fa2 = FrequencyAdaptive(arrs2, td, scale)
result = fa.concatenate(fa2)
self.assertIsInstance(result, ArrayWithUnits)
self.assertEqual((30, 55), result.shape)
def test_can_rotate_90_degrees(self):
sr = SR11025()
hl = sr.half_lapped()
scale = GeometricScale(20, sr.nyquist, 0.175, 64)
td = TimeDimension(frequency=hl.frequency, duration=hl.duration)
fd = FrequencyDimension(scale)
arr = ArrayWithUnits(np.zeros((99, 64)), [td, fd])
rotated = np.rot90(arr)
self.assertEqual((64, 99), rotated.shape)
self.assertEqual(arr.dimensions[0], rotated.dimensions[1])
self.assertEqual(arr.dimensions[1], rotated.dimensions[0])
def test_raises_when_explicit_freq_dimension_and_non_contiguous_array(
self):
td = TimeDimension(frequency=Seconds(1))
scale = GeometricScale(20, 5000, 0.05, 10)
arrs = [np.zeros((10, x)) for x in xrange(1, 11)]
fa1 = FrequencyAdaptive(arrs, td, scale)
arr = np.asarray(fa1)
self.assertRaises(
ValueError, lambda: FrequencyAdaptive(arr,
td,
scale=scale,
explicit_freq_dimension=fa1.
frequency_dimension))
def test_can_apply_frequency_slice_across_multiple_bands(self):
td = TimeDimension(frequency=Seconds(1))
scale = GeometricScale(20, 5000, 0.05, 10)
arrs = [np.zeros((10, x)) for x in xrange(1, 11)]
fa = FrequencyAdaptive(arrs, td, scale)
band = FrequencyBand(300, 3030)
fa2 = fa[:, band]
self.assertIsInstance(fa2, ArrayWithUnits)
self.assertEqual(td, fa2.dimensions[0])
self.assertIsInstance(fa2.dimensions[1], ExplicitFrequencyDimension)
self.assertIsInstance(fa2.dimensions[1].scale, ExplicitScale)
def test_from_arr_with_units(self):
td = TimeDimension(frequency=Seconds(1))
scale = GeometricScale(20, 5000, 0.05, 10)
arrs = [np.zeros((10, x)) for x in xrange(1, 11)]
fa = FrequencyAdaptive(arrs, td, scale)
raw_arr = ArrayWithUnits(np.array(fa), fa.dimensions)
fa2 = FrequencyAdaptive.from_array_with_units(raw_arr)
self.assertIsInstance(fa2, FrequencyAdaptive)
self.assertEqual(fa2.dimensions[0], fa.dimensions[0])
self.assertEqual(fa2.dimensions[1], fa.dimensions[1])
self.assertEqual(fa.shape, fa2.shape)
def test_rasterize_does_not_distort_spectral_shape(self):
n_bands = 8
td = TimeDimension(duration=Seconds(1), frequency=Milliseconds(500))
scale = GeometricScale(start_center_hz=50,
stop_center_hz=5000,
bandwidth_ratio=0.07123,
n_bands=n_bands)
arrs = [
np.random.normal(0, 1, (10, 2**(i + 1))) for i in xrange(n_bands)
]
maxes = [arr.max() for arr in arrs]
fa = FrequencyAdaptive(arrs, td, scale)
rasterized = fa.rasterize(n_coeffs=32)
np.testing.assert_allclose(rasterized.max(axis=(0, 1)), maxes)
def test_returns_array_with_units_where_possible_1d(self):
training_data = np.random.normal(0, 1, size=(100, 9))
_id = SimHashPipeline.process(simhash=training_data)
p = SimHashPipeline(_id)
td = TimeDimension(Seconds(1))
test_data = ArrayWithUnits(
np.random.normal(0, 1, size=(1000, 9)),
dimensions=(td,
FrequencyDimension(GeometricScale(20, 20000, 0.1, 9))))
result = p.pipeline.transform(test_data).data
self.assertEqual((1000, 128), result.shape)
self.assertIsInstance(result, ArrayWithUnits)
self.assertEqual(result.dimensions[0], td)
self.assertIsInstance(result.dimensions[1], IdentityDimension)
def test_can_apply_sliding_window(self):
sr = SR11025()
hl = sr.half_lapped()
scale = GeometricScale(20, sr.nyquist, 0.175, 64)
td = TimeDimension(frequency=hl.frequency, duration=hl.duration)
fd = FrequencyDimension(scale)
arr = ArrayWithUnits(np.zeros((99, 64)), [td, fd])
ts = TimeSlice(duration=hl.frequency * 64)
fs = FrequencyBand(0, sr.nyquist)
windowed = arr.sliding_window((ts, fs))
self.assertEqual((1, 64, 64), windowed.shape)
def test_rasterize_gracefully_handles_band_with_no_energy(self):
n_bands = 8
td = TimeDimension(duration=Seconds(1), frequency=Milliseconds(500))
scale = GeometricScale(start_center_hz=50,
stop_center_hz=5000,
bandwidth_ratio=0.07123,
n_bands=n_bands)
arrs = [
np.random.normal(0, 1, (10, 2**(i + 1))) for i in xrange(n_bands)
]
arrs[0][:] = 0
fa = FrequencyAdaptive(arrs, td, scale)
rasterized = fa.rasterize(n_coeffs=32)
np.testing.assert_allclose(rasterized[:, :, 0], 0)
def test_can_get_single_frequency_band_over_entire_duration(self):
td = TimeDimension(frequency=Seconds(1))
scale = GeometricScale(20, 5000, 0.05, 10)
arrs = [np.zeros((10, x)) for x in xrange(1, 11)]
fa = FrequencyAdaptive(arrs, td, scale)
single_band = fa[:, scale[5]]
self.assertIsInstance(single_band, ArrayWithUnits)
self.assertIsInstance(single_band.dimensions[0], TimeDimension)
self.assertIsInstance(single_band.dimensions[1],
ExplicitFrequencyDimension)
self.assertEqual(1, len(single_band.dimensions[1].scale))
self.assertEqual(1, len(single_band.dimensions[1].slices))
def test_can_multiply_by_frequency_weighting_log_scale(self):
frequency = Seconds(1)
duration = Seconds(1)
scale = GeometricScale(20, 22050, 0.01, 100)
td = TimeDimension(frequency, duration)
fd = FrequencyDimension(scale)
tf = ArrayWithUnits(np.ones((30, 100)), [td, fd])
result = tf * AWeighting()
self.assertIsInstance(result, ArrayWithUnits)
peak_frequency_band = FrequencyBand(9000, 11000)
lower_band = FrequencyBand(100, 300)
peak_slice = np.abs(result[:, peak_frequency_band]).max()
lower_slice = np.abs(result[:, lower_band]).max()
self.assertGreater(peak_slice, lower_slice)
def test_square_form_no_overlap_do_overlap_add(self):
td = TimeDimension(duration=Seconds(1), frequency=Seconds(1))
scale = GeometricScale(20, 5000, 0.05, 120)
arrs = [np.zeros((10, x)) for x in xrange(1, 121)]
fa = FrequencyAdaptive(arrs, td, scale)
square = fa.square(50, do_overlap_add=True)
self.assertEqual(2, square.ndim)
self.assertEqual(500, square.shape[0])
self.assertEqual(120, square.shape[1])
self.assertIsInstance(square, ArrayWithUnits)
self.assertIsInstance(square.dimensions[0], TimeDimension)
self.assertEqual(Seconds(10), square.dimensions[0].end)
self.assertEqual(Milliseconds(20), square.dimensions[0].frequency)
self.assertEqual(Milliseconds(20), square.dimensions[0].duration)
self.assertIsInstance(square.dimensions[1], FrequencyDimension)
self.assertEqual(scale, square.dimensions[1].scale)
def test_can_apply_weighting_to_frequency_adaptive_transform(self):
@simple_in_memory_settings
class Model(ff.BaseModel):
weighted = ff.PickleFeature(
Weighted,
weighting=AWeighting(),
store=False)
scaled = ff.PickleFeature(
InstanceScaling,
needs=weighted,
store=False)
pipeline = ff.PickleFeature(
PreprocessingPipeline,
needs=(weighted, scaled),
store=True)
scale = GeometricScale(100, 1000, 0.1, 15)
training = FrequencyAdaptive(
[np.ones((100, x)) for x in xrange(1, len(scale) + 1)],
time_dimension=TimeDimension(Seconds(1)),
scale=scale)
_id = Model.process(weighted=training)
model = Model(_id)
test = FrequencyAdaptive(
[np.ones((10, x)) for x in xrange(1, len(scale) + 1)],
time_dimension=TimeDimension(Seconds(1)),
scale=scale)
result = model.pipeline.transform(test)
inverted = result.inverse_transform()
self.assertIsInstance(inverted, FrequencyAdaptive)
np.testing.assert_allclose(test, inverted)
def test_raises_when_time_dimension_is_none(self):
scale = GeometricScale(20, 5000, 0.05, 10)
arrs = [np.zeros((10, x)) for x in xrange(1, 11)]
self.assertRaises(ValueError,
lambda: FrequencyAdaptive(arrs, None, scale))