def setUp(self):
self.samplerate = SR22050()
rs = resampled(resample_to=self.samplerate)
window_size = Picoseconds(int(1e12))
wscheme = SampleRate(window_size, window_size)
@simple_in_memory_settings
class Document(rs):
windowed = ArrayWithUnitsFeature(
SlidingWindow,
wscheme=wscheme,
needs=rs.resampled,
store=False)
dct = ArrayWithUnitsFeature(
DCTIV,
needs=windowed,
store=True)
ss = SineSynthesizer(self.samplerate)
self.audio = ss.synthesize(Seconds(5), [440., 660., 880.])
_id = Document.process(meta=self.audio.encode())
self.doc = Document(_id)
def setUp(self):
self.samplerate = SR44100()
rs = resampled(resample_to=self.samplerate)
wscheme = HalfLapped()
@simple_in_memory_settings
class Document(rs):
windowed = ArrayWithUnitsFeature(
SlidingWindow,
wscheme=wscheme,
wfunc=OggVorbisWindowingFunc(),
needs=rs.resampled,
store=False)
fft = ArrayWithUnitsFeature(
FFT,
needs=windowed,
store=False)
centroid = ArrayWithUnitsFeature(
SpectralCentroid,
needs=fft,
store=True)
ss = SineSynthesizer(self.samplerate)
chunks = \
[ss.synthesize(Seconds(1), [440 * i]) for i in range(1, 6)]
self.audio = \
AudioSamples(ArrayWithUnits.concat(chunks), self.samplerate)
_id = Document.process(meta=self.audio.encode())
self.doc = Document(_id)
def test_can_apply_empty_time_slice_to_wrapper(self):
synth = SineSynthesizer(SR11025())
samples = synth.synthesize(Seconds(10))
encoded = samples.encode(fmt='OGG', subtype='VORBIS')
wrapper = OggVorbisWrapper(encoded)
samples = wrapper[TimeSlice()]
expected = Seconds(10) / Seconds(1)
actual = samples.end / Seconds(1)
self.assertAlmostEqual(expected, actual, places=6)
def test_correctly_infers_code_size_16(self):
Model = self._model(slice_size=128,
settings=self._settings_with_event_log())
index = self._index(Model, Model.sliced)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
Model.process(meta=signal.encode())
index._synchronously_process_events()
self.assertEqual(16, index.hamming_db.code_size)
def test_can_convert_to_categorical_distribution(self):
samplerate = SR11025()
synth = SineSynthesizer(samplerate)
samples = synth.synthesize(Seconds(4), [220, 440, 880])
_, windowed = samples.sliding_window_with_leftovers(
TimeSlice(duration=samplerate.frequency * 512),
TimeSlice(duration=samplerate.frequency * 256))
c = categorical(windowed, mu=255)
self.assertEqual(windowed.shape + (255 + 1, ), c.shape)
np.testing.assert_allclose(c.sum(axis=-1), 1)
def test_can_convert_to_categorical_distribution(self):
samplerate = SR11025()
synth = SineSynthesizer(samplerate)
samples = synth.synthesize(Seconds(4), [220, 440, 880])
_, windowed = samples.sliding_window_with_leftovers(
TimeSlice(duration=samplerate.frequency * 512),
TimeSlice(duration=samplerate.frequency * 256))
c = categorical(windowed, mu=255)
self.assertEqual(windowed.shape + (255 + 1,), c.shape)
np.testing.assert_allclose(c.sum(axis=-1), 1)
def test_listen_raises_if_model_class_has_no_event_log_configured(self):
Model = self._model(slice_size=64,
settings=self._settings_with_no_event_log())
index = self._index(Model, Model.sliced)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
Model.process(meta=signal.encode())
self.assertRaises(ValueError,
lambda: index._synchronously_process_events())
def correctly_infers_index_name(self):
Model = self._model(slice_size=128,
settings=self._settings_with_event_log())
index = self._index(Model, Model.sliced)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
Model.process(meta=signal.encode())
index._synchronously_process_events()
self.assertTrue('index.sliced' in index.hamming_db.path)
def test_correctly_infers_code_size_16(self):
Model = self._model(
slice_size=128,
settings=self._settings_with_event_log())
index = self._index(Model, Model.sliced)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
Model.process(meta=signal.encode())
index._synchronously_process_events()
self.assertEqual(16, index.hamming_db.code_size)
def test_listen_raises_if_model_class_has_no_event_log_configured(self):
Model = self._model(
slice_size=64,
settings=self._settings_with_no_event_log())
index = self._index(Model, Model.sliced)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
Model.process(meta=signal.encode())
self.assertRaises(
ValueError, lambda: index._synchronously_process_events())
def test_can_add_already_packed_feature(self):
Model = self._model(slice_size=128,
settings=self._settings_with_no_event_log())
index = self._index(Model, Model.packed)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
_id = Model.process(meta=signal.encode())
model = Model(_id)
index.add(_id)
self.assertEqual(len(model.packed), len(index))
def correctly_infers_index_name(self):
Model = self._model(
slice_size=128,
settings=self._settings_with_event_log())
index = self._index(Model, Model.sliced)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
Model.process(meta=signal.encode())
index._synchronously_process_events()
self.assertTrue('index.sliced' in index.hamming_db.path)
def test_can_invert_categorical_distribution(self):
samplerate = SR11025()
synth = SineSynthesizer(samplerate)
samples = synth.synthesize(Seconds(4), [220, 440, 880])
_, windowed = samples.sliding_window_with_leftovers(
TimeSlice(duration=samplerate.frequency * 512),
TimeSlice(duration=samplerate.frequency * 256))
c = categorical(windowed, mu=255)
inverted = inverse_categorical(c, mu=255)
self.assertEqual(windowed.shape, inverted.shape)
self.assertIsInstance(inverted, ArrayWithUnits)
self.assertSequenceEqual(windowed.dimensions, inverted.dimensions)
def test_can_invert_categorical_distribution(self):
samplerate = SR11025()
synth = SineSynthesizer(samplerate)
samples = synth.synthesize(Seconds(4), [220, 440, 880])
_, windowed = samples.sliding_window_with_leftovers(
TimeSlice(duration=samplerate.frequency * 512),
TimeSlice(duration=samplerate.frequency * 256))
c = categorical(windowed, mu=255)
inverted = inverse_categorical(c, mu=255)
self.assertEqual(windowed.shape, inverted.shape)
self.assertIsInstance(inverted, ArrayWithUnits)
self.assertSequenceEqual(windowed.dimensions, inverted.dimensions)
def test_can_add_already_packed_feature(self):
Model = self._model(
slice_size=128,
settings=self._settings_with_no_event_log())
index = self._index(Model, Model.packed)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
_id = Model.process(meta=signal.encode())
model = Model(_id)
index.add(_id)
self.assertEqual(len(model.packed), len(index))
def test_can_phase_shift_2d_signal(self):
samplerate = SR22050()
samples = SineSynthesizer(samplerate) \
.synthesize(Milliseconds(2500), [220, 440, 880])
windowsize = TimeSlice(duration=Milliseconds(200))
stepsize = TimeSlice(duration=Milliseconds(100))
_, windowed = samples.sliding_window_with_leftovers(
windowsize=windowsize, stepsize=stepsize, dopad=True)
coeffs = fft(windowed)
shifted = phase_shift(coeffs, samplerate, Milliseconds(40))
synth = FFTSynthesizer()
new_samples = synth.synthesize(shifted).squeeze()
self.assertNotEqual(0, self._mean_squared_error(samples, new_samples))
def test_hamming_db_is_initialized_if_docs_exist(self):
Model = self._model(slice_size=128,
settings=self._settings_with_event_log())
index = self._index(Model, Model.sliced)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
Model.process(meta=signal.encode())
index._synchronously_process_events()
index2 = self._index(Model, Model.sliced)
self.assertIsNotNone(index2.hamming_db)
self.assertEqual(16, index2.hamming_db.code_size)
def test_perfect_reconstruction(self):
synth = SineSynthesizer(SR22050())
audio = synth.synthesize(Seconds(1), [440., 660., 880.])
node = DCTIV()
coeffs = node._process_raw(audio[None, :])
recon = node._process_raw(coeffs)[0]
# see? it's do-able w/ dct
dct_coeffs = scipy.fftpack.dct(audio[None, :], norm='ortho')
inverse_dct = scipy.fftpack.idct(dct_coeffs, norm='ortho')[0]
np.testing.assert_almost_equal(inverse_dct, audio, decimal=4)
np.testing.assert_almost_equal(recon, audio, decimal=4)
def test_can_phase_shift_2d_signal(self):
samplerate = SR22050()
samples = SineSynthesizer(samplerate) \
.synthesize(Milliseconds(2500), [220, 440, 880])
windowsize = TimeSlice(duration=Milliseconds(200))
stepsize = TimeSlice(duration=Milliseconds(100))
_, windowed = samples.sliding_window_with_leftovers(
windowsize=windowsize, stepsize=stepsize, dopad=True)
coeffs = fft(windowed)
shifted = phase_shift(coeffs, samplerate, Milliseconds(40))
synth = FFTSynthesizer()
new_samples = synth.synthesize(shifted).squeeze()
self.assertNotEqual(0, self._mean_squared_error(samples, new_samples))
def test_2d_phase_shift_returns_correct_shape(self):
samplerate = SR22050()
samples = SineSynthesizer(samplerate) \
.synthesize(Milliseconds(2500), [220, 440, 880])
windowsize = TimeSlice(duration=Milliseconds(200))
stepsize = TimeSlice(duration=Milliseconds(100))
_, windowed = samples.sliding_window_with_leftovers(
windowsize=windowsize, stepsize=stepsize, dopad=True)
coeffs = fft(windowed)
shifted = phase_shift(coeffs=coeffs,
samplerate=samplerate,
time_shift=Milliseconds(40),
frequency_band=FrequencyBand(50, 5000))
self.assertEqual(coeffs.shape, shifted.shape)
def test_hamming_db_is_initialized_if_docs_exist(self):
Model = self._model(
slice_size=128,
settings=self._settings_with_event_log())
index = self._index(Model, Model.sliced)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
Model.process(meta=signal.encode())
index._synchronously_process_events()
index2 = self._index(Model, Model.sliced)
self.assertIsNotNone(index2.hamming_db)
self.assertEqual(16, index2.hamming_db.code_size)
def test_can_roundtrip_query(self):
Model = self._model(slice_size=128,
settings=self._settings_with_event_log())
index = self._index(Model, Model.sliced)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
Model.process(meta=signal.encode())
index._synchronously_process_events()
results = index.random_search(n_results=5)
decoded = index.decode_query(results.query)
encoded = index.encode_query(decoded)
self.assertEqual(results.query, encoded)
def test_can_roundtrip_query(self):
Model = self._model(
slice_size=128,
settings=self._settings_with_event_log())
index = self._index(Model, Model.sliced)
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
Model.process(meta=signal.encode())
index._synchronously_process_events()
results = index.random_search(n_results=5)
decoded = index.decode_query(results.query)
encoded = index.encode_query(decoded)
self.assertEqual(results.query, encoded)
def test_2d_phase_shift_returns_correct_shape(self):
samplerate = SR22050()
samples = SineSynthesizer(samplerate) \
.synthesize(Milliseconds(2500), [220, 440, 880])
windowsize = TimeSlice(duration=Milliseconds(200))
stepsize = TimeSlice(duration=Milliseconds(100))
_, windowed = samples.sliding_window_with_leftovers(
windowsize=windowsize, stepsize=stepsize, dopad=True)
coeffs = fft(windowed)
shifted = phase_shift(
coeffs=coeffs,
samplerate=samplerate,
time_shift=Milliseconds(40),
frequency_band=FrequencyBand(50, 5000))
self.assertEqual(coeffs.shape, shifted.shape)
def test_raises_value_error_when_specified_axis_not_frequency_dim(self):
samplerate = SR22050()
samples = SineSynthesizer(samplerate) \
.synthesize(Milliseconds(2500), [220, 440, 880])
self.assertRaises(
ValueError,
lambda: phase_shift(samples, samplerate, Milliseconds(10)))
def test_can_phase_shift_1d_signal(self):
samplerate = SR22050()
samples = SineSynthesizer(samplerate) \
.synthesize(Milliseconds(5000), [220, 440, 880])
coeffs = fft(samples)
shifted = phase_shift(coeffs, samplerate, Milliseconds(10))
new_samples = np.fft.irfft(shifted, norm='ortho')
self.assertNotEqual(0, self._mean_squared_error(samples, new_samples))
def test_perfect_reconstruction_using_overlap_add(self):
synth = SineSynthesizer(SR22050())
audio = synth.synthesize(Seconds(10), [440., 660., 880.])
sr = SampleRate(duration=Seconds(1), frequency=Milliseconds(500))
windowed = audio.sliding_window(sr)
mdct = MDCT()
coeffs = list(mdct._process(windowed * OggVorbisWindowingFunc()))[0]
mdct_synth = MDCTSynthesizer()
recon = mdct_synth.synthesize(coeffs)
# take a slice, so we can ignore boundary conditions
slce = TimeSlice(start=Seconds(1), duration=Seconds(8))
np.testing.assert_allclose(recon[slce], audio[slce])
def test_1d_phase_shift_returns_correct_size(self):
samplerate = SR22050()
samples = SineSynthesizer(samplerate) \
.synthesize(Milliseconds(5500), [220, 440, 880])
coeffs = fft(samples)
shifted = phase_shift(coeffs=coeffs,
samplerate=samplerate,
time_shift=Milliseconds(5500),
frequency_band=FrequencyBand(50, 5000))
self.assertEqual(coeffs.shape, shifted.shape)
def test_apply_scale_to_self_is_identity_function(self):
samplerate = SR22050()
samples = SineSynthesizer(samplerate).synthesize(Milliseconds(8888))
wscheme = samplerate.windowing_scheme(256, 128)
tf = stft(samples, wscheme, HanningWindowingFunc())
scale = tf.dimensions[-1].scale
transformed = apply_scale(tf, scale, HanningWindowingFunc())
self.assertEqual(tf.shape, transformed.shape)
self.assertEqual(tf.dimensions[0], transformed.dimensions[0])
self.assertEqual(tf.dimensions[1], transformed.dimensions[1])
def test_can_add_additional_data_to_index(self):
Model = self._model(slice_size=128,
settings=self._settings_with_event_log())
index = self._index(Model,
Model.sliced,
web_url=lambda doc, ts: doc.meta['web_url'])
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
meta = AudioMetaData(uri=signal.encode(),
web_url='https://example.com')
_id = Model.process(meta=meta)
index._synchronously_process_events()
results = list(index.random_search(n_results=5))
result_id, ts, extra_data = results[0]
self.assertEqual(_id, result_id)
self.assertEqual('https://example.com', extra_data['web_url'])
def setUp(self):
self.samplerate = SR22050()
rs = resampled(resample_to=self.samplerate)
wscheme = HalfLapped()
@simple_in_memory_settings
class Document(rs):
windowed = ArrayWithUnitsFeature(
SlidingWindow,
wscheme=wscheme,
wfunc=OggVorbisWindowingFunc(),
needs=rs.resampled,
store=False)
fft = ArrayWithUnitsFeature(
FFT,
needs=windowed,
store=False)
flatness = ArrayWithUnitsFeature(
SpectralFlatness,
needs=fft,
store=True)
# create a pure sine wave that fades out
ss = SineSynthesizer(self.samplerate)
sine = ss.synthesize(Seconds(5), [440.])
sine_envelope = np.linspace(1.0, 0.0, len(sine))
sine *= sine_envelope
# create noise
ns = NoiseSynthesizer(self.samplerate)
noise = ns.synthesize(Seconds(5))
noise_envelope = np.linspace(0.0, 1.0, len(noise))
noise *= noise_envelope
# mix the sine wave and noise together
self.audio = sine + noise
_id = Document.process(meta=self.audio.encode())
self.doc = Document(_id)
def test_can_add_additional_data_to_index(self):
Model = self._model(
slice_size=128,
settings=self._settings_with_event_log())
index = self._index(
Model,
Model.sliced,
web_url=lambda doc, ts: doc.meta['web_url'])
signal = SineSynthesizer(SR11025()) \
.synthesize(Seconds(5), [220, 440, 880])
meta = AudioMetaData(uri=signal.encode(), web_url='https://example.com')
_id = Model.process(meta=meta)
index._synchronously_process_events()
results = list(index.random_search(n_results=5))
result_id, ts, extra_data = results[0]
self.assertEqual(_id, result_id)
self.assertEqual('https://example.com', extra_data['web_url'])
def setUp(self):
self.samplerate = SR11025()
rs = resampled(resample_to=self.samplerate)
wscheme = HalfLapped()
@simple_in_memory_settings
class Document(rs):
windowed = ArrayWithUnitsFeature(SlidingWindow,
wscheme=wscheme,
needs=rs.resampled,
store=False)
mdct = ArrayWithUnitsFeature(MDCT, needs=windowed, store=True)
ss = SineSynthesizer(self.samplerate)
self.audio = ss.synthesize(Seconds(5), [440., 660., 880.])
_id = Document.process(meta=self.audio.encode())
self.doc = Document(_id)
def test_can_phase_shift_1d_signal_180_degrees(self):
samplerate = SR22050()
samples = SineSynthesizer(samplerate) \
.synthesize(Seconds(1), [110, 220, 440, 880])
coeffs = fft(samples)
shifted = phase_shift(coeffs=coeffs,
samplerate=samplerate,
time_shift=-Milliseconds(1000),
frequency_band=FrequencyBand(50, 5000))
new_samples = np.fft.irfft(shifted, norm='ortho')
self.assertAlmostEqual(0,
self._mean_squared_error(samples,
new_samples), 1)
def test_should_have_correct_shape_and_dimensions(self):
samplerate = SR22050()
samples = SineSynthesizer(samplerate).synthesize(Milliseconds(8888))
wscheme = samplerate.windowing_scheme(256, 128)
tf = stft(samples, wscheme, HanningWindowingFunc())
rg = rainbowgram(tf, cm.rainbow)
self.assertEqual(3, rg.ndim)
self.assertEqual(tf.shape + (3, ), rg.shape)
self.assertEqual(3, len(rg.dimensions))
self.assertEqual(tf.dimensions[0], rg.dimensions[0])
self.assertEqual(tf.dimensions[1], rg.dimensions[1])
self.assertEqual(rg.dimensions[2], IdentityDimension())
self.assertEqual(3, rg.shape[-1])
def setUp(self):
self.samplerate = SR11025()
rs = resampled(resample_to=self.samplerate)
wscheme = HalfLapped()
@simple_in_memory_settings
class Document(rs):
windowed = ArrayWithUnitsFeature(
SlidingWindow,
wscheme=wscheme,
needs=rs.resampled,
store=False)
mdct = ArrayWithUnitsFeature(
MDCT,
needs=windowed,
store=True)
ss = SineSynthesizer(self.samplerate)
self.audio = ss.synthesize(Seconds(5), [440., 660., 880.])
_id = Document.process(meta=self.audio.encode())
self.doc = Document(_id)
def test_can_pitch_shift_audio_samples(self):
sr = SR22050()
samples = SineSynthesizer(sr).synthesize(Milliseconds(6666), [440])
shifted = pitch_shift(samples, 1.0).squeeze()
self.assertEqual(len(samples), len(shifted))
def test_pad_with_samples_adds_silence_at_end(self):
synth = SineSynthesizer(SR11025())
samples = synth.synthesize(Seconds(2))
padded = samples.pad_with_silence(Seconds(4))
silence = padded[TimeSlice(start=Seconds(2))]
self.assertEqual(0, silence.sum())
def test_pad_with_samples_adds_silence_at_end(self):
synth = SineSynthesizer(SR11025())
samples = synth.synthesize(Seconds(2))
padded = samples.pad_with_silence(Seconds(4))
silence = padded[TimeSlice(start=Seconds(2))]
self.assertEqual(0, silence.sum())
