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_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_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())