Exemplo n.º 1
0
    def test_wpe_v6_vs_v7(self):
        desired = wpe.wpe_v6(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='full')
        actual = wpe.wpe_v7(self.Y, self.K, self.delay, statistics_mode='full')
        tc.assert_allclose(actual, desired, atol=1e-10)

        desired = wpe.wpe_v6(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='valid')
        actual = wpe.wpe_v7(self.Y,
                            self.K,
                            self.delay,
                            statistics_mode='valid')
        tc.assert_allclose(actual, desired, atol=1e-10)

        desired = wpe.wpe_v6(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='valid')
        actual = wpe.wpe_v7(self.Y, self.K, self.delay, statistics_mode='full')
        tc.assert_raises(AssertionError, tc.assert_array_equal, desired,
                         actual)
Exemplo n.º 2
0
    def test_wpe_v8(self):
        desired = wpe.wpe_v6(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='valid')
        actual = wpe.wpe_v8(self.Y,
                            self.K,
                            self.delay,
                            statistics_mode='valid')
        tc.assert_allclose(actual, desired, atol=1e-6)

        desired = wpe.wpe_v7(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='valid')
        actual = wpe.wpe_v8(self.Y,
                            self.K,
                            self.delay,
                            statistics_mode='valid')
        tc.assert_allclose(actual, desired, atol=1e-6)

        desired = wpe.wpe_v6(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='full')
        actual = wpe.wpe_v8(self.Y, self.K, self.delay, statistics_mode='full')
        tc.assert_allclose(actual, desired, atol=1e-6)

        desired = wpe.wpe_v7(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='full')
        actual = wpe.wpe_v8(self.Y, self.K, self.delay, statistics_mode='full')
        tc.assert_allclose(actual, desired, atol=1e-6)
Exemplo n.º 3
0
    def test_wpe_v1_vs_v7(self):
        desired = wpe.wpe_v1(self.Y, self.K, self.delay)
        actual = wpe.wpe_v7(self.Y, self.K, self.delay, mode='cut')
        tc.assert_allclose(actual, desired)

        actual = wpe.wpe_v7(self.Y, self.K, self.delay, mode='pad')
        with tc.assert_raises(Exception):
            tc.assert_allclose(actual, desired, rtol=1e-3, atol=1e-3)
Exemplo n.º 4
0
    def test_wpe_batched_multi_freq(self):
        def to_batched_multi_freq(x):
            return np.array([
                [x, x * 2],
                [x * 3, x * 4],
                [x * 5, x * 6],
            ])

        Y_batched_multi_freq = to_batched_multi_freq(self.Y)

        tc.assert_raises(NotImplementedError,
                         wpe.wpe_v0,
                         Y_batched_multi_freq,
                         self.K,
                         self.delay,
                         statistics_mode='full')

        desired = wpe.wpe_v7(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='full')
        desired = to_batched_multi_freq(desired)
        actual = wpe.wpe_v7(Y_batched_multi_freq,
                            self.K,
                            self.delay,
                            statistics_mode='full')
        assert desired.shape == (3, 2, self.D, self.T)
        assert actual.shape == (3, 2, self.D, self.T)
        tc.assert_allclose(actual, desired, atol=1e-6)

        desired = wpe.wpe_v6(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='full')
        desired = to_batched_multi_freq(desired)
        actual = wpe.wpe_v6(Y_batched_multi_freq,
                            self.K,
                            self.delay,
                            statistics_mode='full')
        assert desired.shape == (3, 2, self.D, self.T)
        assert actual.shape == (3, 2, self.D, self.T)
        tc.assert_allclose(actual, desired, atol=1e-6)

        desired = wpe.wpe_v8(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='full')
        desired = to_batched_multi_freq(desired)
        actual = wpe.wpe_v8(Y_batched_multi_freq,
                            self.K,
                            self.delay,
                            statistics_mode='full')
        assert desired.shape == (3, 2, self.D, self.T)
        assert actual.shape == (3, 2, self.D, self.T)
        tc.assert_allclose(actual, desired, atol=1e-6)
Exemplo n.º 5
0
 def test_wpe(self):
     with self.test_session() as sess:
         Y = tf.convert_to_tensor(self.Y)
         enhanced, inv_power = tf_wpe.single_frequency_wpe(Y, iterations=1)
         enhanced = sess.run(enhanced)
     ref = wpe.wpe_v7(self.Y, iterations=1, statistics_mode='valid')
     np.testing.assert_allclose(enhanced, ref)
Exemplo n.º 6
0
    def test_wpe_multi_freq(self):
        desired = wpe.wpe_v0(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='full')
        desired = [desired, desired]
        actual = wpe.wpe_v0(np.array([self.Y, self.Y]),
                            self.K,
                            self.delay,
                            statistics_mode='full')
        tc.assert_allclose(actual, desired, atol=1e-6)

        desired = wpe.wpe_v7(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='full')
        desired = [desired, desired]
        actual = wpe.wpe_v7(np.array([self.Y, self.Y]),
                            self.K,
                            self.delay,
                            statistics_mode='full')
        tc.assert_allclose(actual, desired, atol=1e-6)

        desired = wpe.wpe_v6(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='full')
        desired = [desired, desired]
        actual = wpe.wpe_v6(np.array([self.Y, self.Y]),
                            self.K,
                            self.delay,
                            statistics_mode='full')
        tc.assert_allclose(actual, desired, atol=1e-6)

        desired = wpe.wpe_v8(self.Y,
                             self.K,
                             self.delay,
                             statistics_mode='full')
        desired = [desired, desired]
        actual = wpe.wpe_v8(np.array([self.Y, self.Y]),
                            self.K,
                            self.delay,
                            statistics_mode='full')
        tc.assert_allclose(actual, desired, atol=1e-6)
Exemplo n.º 7
0
 def test_wpe_v6_vs_v7(self):
     desired = wpe.wpe_v6(self.Y, self.K, self.delay)
     actual = wpe.wpe_v7(self.Y, self.K, self.delay)
     tc.assert_allclose(actual, desired, atol=1e-10)