def test_concat_along_first_axis(self): td1 = TimeDimension(Seconds(1), Seconds(2)) ts1 = ArrayWithUnits(np.ones((10, 3)), [td1, IdentityDimension()]) td2 = TimeDimension(Seconds(1), Seconds(2)) ts2 = ArrayWithUnits(np.ones((13, 3)), [td2, IdentityDimension()]) result = ArrayWithUnits.concat([ts1, ts2]) self.assertEqual((23, 3), result.shape)
def test_concat_with_differing_durations(self): td1 = TimeDimension(Seconds(1), Seconds(2)) ts1 = ArrayWithUnits(np.ones((10, 3)), [td1, IdentityDimension()]) td2 = TimeDimension(Seconds(1), Seconds(3)) ts2 = ArrayWithUnits(np.ones((13, 3)), [td2, IdentityDimension()]) self.assertRaises(ValueError, lambda: ArrayWithUnits.concat([ts1, ts2]))
def test_concat_along_second_axis(self): td1 = TimeDimension(Seconds(1), Seconds(2)) ts1 = ArrayWithUnits(np.ones((10, 3)), [td1, IdentityDimension()]) td2 = TimeDimension(Seconds(1), Seconds(2)) ts2 = ArrayWithUnits(np.ones((10, 5)), [td2, IdentityDimension()]) result = ArrayWithUnits.concat([ts1, ts2], axis=1) self.assertEqual((10, 8), result.shape) self.assertIsInstance(result.dimensions[0], TimeDimension) self.assertIsInstance(result.dimensions[1], IdentityDimension)
def test_concat_with_differing_freqs(self): ts = ArrayWithUnits(np.ones( (10, 3)), [TimeDimension(Seconds(2), Seconds(2)), IdentityDimension()]) ts2 = ArrayWithUnits(np.ones( (13, 3)), [TimeDimension(Seconds(1), Seconds(2)), IdentityDimension()]) self.assertRaises(ValueError, lambda: ArrayWithUnits.concat([ts, ts2]))
def test_concatenation_with_matching_freqs_and_duration_results_in_crts( self): ts = ArrayWithUnits(np.ones( (10, 3)), [TimeDimension(Seconds(1), Seconds(2)), IdentityDimension()]) ts2 = ArrayWithUnits(np.ones( (13, 3)), [TimeDimension(Seconds(1), Seconds(2)), IdentityDimension()]) result = ts.concatenate(ts2) self.assertIsInstance(result, ArrayWithUnits) self.assertEqual((23, 3), result.shape)
def test_can_invert_array_with_units(self): td = TimeDimension(Seconds(1)) fd = FrequencyDimension(LinearScale(FrequencyBand(0, 20000), 100)) dimensions = [IdentityDimension(), td, fd] training = ArrayWithUnits(np.zeros((10, 5, 100)), dimensions) Model = self.get_model(slicex=FrequencyBand(1000, 10000)) _id = Model.process(sliced=training) model = Model(_id) data = ArrayWithUnits(np.ones((2, 5, 100)), dimensions) transformed = model.pipeline.transform(data) inverted = transformed.inverse_transform() self.assertEqual((2, 5, 100), inverted.shape) self.assertEqual(IdentityDimension(), inverted.dimensions[0]) self.assertEqual(td, inverted.dimensions[1]) self.assertEqual(fd, inverted.dimensions[2])
def _enqueue(self, data, pusher): if self._r is None: shape = (self._nsamples,) + data.shape[1:] self._r = np.zeros(shape, dtype=data.dtype) try: self._r = ArrayWithUnits( self._r, (IdentityDimension(),) + data.dimensions[1:]) except AttributeError: # samples were likely a plain numpy array, and not an # ArrayWithUnits instance pass diff = 0 if self._index < self._nsamples: diff = self._nsamples - self._index available = len(data[:diff]) self._r[self._index: self._index + available] = data[:diff] self._index += available remaining = len(data[diff:]) if not remaining: return indices = np.random.random_integers(0, self._index, size=remaining) indices = indices[indices < self._nsamples] self._r[indices, ...] = data[diff:][list(range(len(indices)))] self._index += remaining
def test_can_mix_time_slice_and_integer_indices(self): arr = np.ones((10, 5)) freq = Seconds(1) ts = ArrayWithUnits(arr, [TimeDimension(freq), IdentityDimension()]) sl = TimeSlice(duration=Seconds(5), start=Seconds(5)) ts2 = ts[sl, 2:] self.assertEqual((5, 3), ts2.shape)
def test_should_preserve_time_dimension_in_forward_transform(self): td = TimeDimension(Seconds(1)) td2 = TimeDimension(Milliseconds(500)) fd = FrequencyDimension(LinearScale(FrequencyBand(10, 100), 3)) training_data = ArrayWithUnits(np.zeros((10, 5, 3)), dimensions=(IdentityDimension(), td2, fd)) _id = Document.process(l=training_data) doc = Document(_id) test_data = ArrayWithUnits(np.zeros((11, 5, 3)), dimensions=(td, td2, fd)) result = doc.pipeline.transform(test_data) self.assertEqual((11, 15), result.data.shape) self.assertIsInstance(result.data, ArrayWithUnits) self.assertEqual(td, result.data.dimensions[0]) self.assertEqual(IdentityDimension(), result.data.dimensions[1])
def categorical(x, mu=255, normalize=True): """ Mu-law compress a block of audio samples, and convert them into a categorical distribution """ if normalize: # normalize the signal mx = x.max() x = np.divide(x, mx, where=mx != 0) # mu law compression x = mu_law(x) # translate and scale to [0, 1] x = (x - x.min()) * 0.5 # convert to the range [0, 255] x = (x * mu).astype(np.uint8) # create the array to house the categorical representation c = np.zeros((np.product(x.shape), mu + 1), dtype=np.uint8) c[np.arange(len(c)), x.flatten()] = 1 return ArrayWithUnits(c.reshape(x.shape + (mu + 1, )), x.dimensions + (IdentityDimension(), ))
def test_inversion_returns_time_series(self): data = np.random.random_sample((33, 30)) ts = ArrayWithUnits(data, [TimeDimension(Seconds(1)), IdentityDimension()]) inverted = self.invert_and_assert_class(ts) self.assertEqual(Seconds(1), inverted.dimensions[0].frequency)
def test_can_slice_frequency_dim_with_negative_start_hz(self): scale = LinearScale(FrequencyBand(0, 100), 10) arr = ArrayWithUnits(np.zeros((13, 10)), [IdentityDimension(), FrequencyDimension(scale)]) sliced = arr[:, -Hertz(20):] self.assertEqual((13, 3), sliced.shape)
def _process(self, data): data = np.abs(data) bfcc = dct(safe_log(data), axis=1) \ [:, self._exclude: self._exclude + self._n_coeffs] yield ArrayWithUnits( bfcc.copy(), [data.dimensions[0], IdentityDimension()])
def x(d, model=None): from zounds.core import ArrayWithUnits, IdentityDimension transformed = model.transform(d.reshape((d.shape[0], -1))) try: return ArrayWithUnits(transformed, (d.dimensions[0], IdentityDimension())) except AttributeError: return transformed
def test_raises_when_first_dimension_is_not_time_dimension(self): raw = np.zeros((10, 3)) arr = ArrayWithUnits(raw, dimensions=[ IdentityDimension(), TimeDimension(frequency=Seconds(1)) ]) self.assertRaises(ValueError, lambda: ConstantRateTimeSeries(arr))
def test_sum_along_second_axis(self): td = TimeDimension(Seconds(1), Seconds(2)) ts = ArrayWithUnits(np.ones((10, 3)), [td, IdentityDimension()]) result = ts.sum(axis=1) self.assertIsInstance(result, ArrayWithUnits) self.assertEqual((10, ), result.shape) self.assertEqual(1, len(result.dimensions)) self.assertIsInstance(result.dimensions[0], TimeDimension)
def test_discrete_samples_multiple_dimensions(self): sr = SR22050() samples = SilenceSynthesizer(sr).synthesize(Milliseconds(6666)) stacked = ArrayWithUnits( np.zeros((10, ) + samples.shape, dtype=samples.dtype), (IdentityDimension(), ) + samples.dimensions) stacked[:] = samples self.assertEqual((512, 1024), HalfLapped().discrete_samples(stacked))
def test_can_round_trip_mixed_dimensions(self): original = [ IdentityDimension(), TimeDimension(Seconds(1), Milliseconds(500)), FrequencyDimension(LinearScale(FrequencyBand(100, 1000), 10)) ] restored = self.roundtrip(original) self.assertSequenceEqual(original, restored)
def test_can_sum_2d_timeseries(self): arr = np.zeros((10, 3)) freq = Seconds(1) ts = ArrayWithUnits(arr, [TimeDimension(freq), IdentityDimension()]) ts2 = ts.sum(axis=1) self.assertIsInstance(ts2, ArrayWithUnits) self.assertEqual(1, len(ts2.dimensions)) self.assertEqual(freq, ts2.dimensions[0].frequency) self.assertEqual(freq, ts2.dimensions[0].duration)
def test_can_round_trip_1d_identity_dimension(self): raw = np.arange(10) arr = ArrayWithUnits(raw, (IdentityDimension(), )) decoded = self._roundtrip(arr) self.assertIsInstance(decoded, ArrayWithUnits) self.assertEqual(1, len(decoded.dimensions)) d = decoded.dimensions[0] self.assertIsInstance(d, IdentityDimension) np.testing.assert_allclose(decoded, raw)
def test_can_pack_bits(self): raw = np.random.binomial(1, 0.5, (100, 64)) arr = ArrayWithUnits(raw, [TimeDimension(Seconds(1)), IdentityDimension()]) decoded = self._roundtrip(arr, encoder=PackedArrayWithUnitsEncoder()) self.assertIsInstance(decoded, ArrayWithUnits) self.assertEqual(2, len(decoded.dimensions)) self.assertEqual((100, 8), decoded.shape)
def test_can_stretch_audio_batch(self): sr = SR22050() samples = SilenceSynthesizer(sr).synthesize(Milliseconds(6666)) stacked = ArrayWithUnits( np.zeros((10, ) + samples.shape, dtype=samples.dtype), (IdentityDimension(), ) + samples.dimensions) stacked[:] = samples stretched = time_stretch(stacked, 2.0) self.assertEqual(10, stretched.shape[0]) self.assertEqual(int(len(samples) // 2), stretched.shape[1])
def test_can_slice_frequency_dim_with_end_hz(self): scale = LinearScale(FrequencyBand(0, 100), 10) arr = ArrayWithUnits(np.zeros((13, 10)), [IdentityDimension(), FrequencyDimension(scale)]) sliced = arr[:, :Hertz(50)] self.assertEqual((13, 5), sliced.shape) self.assertEqual( FrequencyDimension(LinearScale(FrequencyBand(0, 50), 5)), sliced.dimensions[-1])
def x(d, network=None, chunk_size=None): from zounds.core import ArrayWithUnits, IdentityDimension from zounds.learn import apply_network result = apply_network(network, d, chunksize=chunk_size) try: return ArrayWithUnits( result, [d.dimensions[0], IdentityDimension()]) except (AttributeError, ValueError): return result
def test_can_add_axis_at_end(self): _id = IdentityDimension() td = TimeDimension(Seconds(1), Seconds(1)) fd = FrequencyDimension(LinearScale(FrequencyBand(20, 22050), 100)) tf = ArrayWithUnits(np.ones((3, 30, 100)), [_id, td, fd]) tf2 = tf[..., None] self.assertEqual(4, tf2.ndim) self.assertIsInstance(tf2.dimensions[0], IdentityDimension) self.assertIsInstance(tf2.dimensions[1], TimeDimension) self.assertIsInstance(tf2.dimensions[2], FrequencyDimension) self.assertIsInstance(tf2.dimensions[3], IdentityDimension)
def test_ellipsis(self): scale = LinearScale(FrequencyBand(0, 10000), 100) arr = ArrayWithUnits(np.zeros((10, 3, 100)), [ IdentityDimension(), TimeDimension(Seconds(1)), FrequencyDimension(scale) ]) sliced = arr[..., FrequencyBand(1000, 5000)] self.assertEqual((10, 3, 41), sliced.shape) self.assertIsInstance(sliced.dimensions[0], IdentityDimension) self.assertIsInstance(sliced.dimensions[1], TimeDimension) self.assertIsInstance(sliced.dimensions[2], FrequencyDimension)
def _init_arr(self, samples): if self.arr is not None: return shape = (self.nsamples,) + samples.shape[1:] self.arr = np.zeros(shape, dtype=self.dtype or samples.dtype) try: self.arr = ArrayWithUnits( self.arr, (IdentityDimension(),) + samples.dimensions[1:]) except AttributeError: pass
def test_can_iterate_over_timeseries(self): tf = ArrayWithUnits(np.ones((10, 10)), dimensions=[ TimeDimension(Seconds(1), Seconds(1)), IdentityDimension() ]) rows = [row for row in tf] self.assertEqual(10, len(rows)) for row in rows: self.assertIsInstance(row, ArrayWithUnits) self.assertIsInstance(row.dimensions[0], IdentityDimension) self.assertEqual((10, ), row.shape)
def __new__(cls, array, samplerate): if array.ndim == 1: dimensions = [TimeDimension(*samplerate)] elif array.ndim == 2: dimensions = [TimeDimension(*samplerate), IdentityDimension()] else: raise ValueError( 'array must be one (mono) or two (multi-channel) dimensions') if not isinstance(samplerate, AudioSampleRate): raise TypeError('samplerate should be an AudioSampleRate instance') return ArrayWithUnits.__new__(cls, array, dimensions)
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])