diff options
Diffstat (limited to 'modules/audio_processing/agc2/rnn_vad/rnn_unittest.cc')
| -rw-r--r-- | modules/audio_processing/agc2/rnn_vad/rnn_unittest.cc | 180 |
1 files changed, 180 insertions, 0 deletions
diff --git a/modules/audio_processing/agc2/rnn_vad/rnn_unittest.cc b/modules/audio_processing/agc2/rnn_vad/rnn_unittest.cc new file mode 100644 index 0000000000..d774c6d557 --- /dev/null +++ b/modules/audio_processing/agc2/rnn_vad/rnn_unittest.cc @@ -0,0 +1,180 @@ +/* + * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include <algorithm> +#include <array> +#include <vector> + +#include "modules/audio_processing/agc2/rnn_vad/rnn.h" +#include "modules/audio_processing/agc2/rnn_vad/test_utils.h" +#include "rtc_base/checks.h" +#include "test/gtest.h" +#include "third_party/rnnoise/src/rnn_activations.h" +#include "third_party/rnnoise/src/rnn_vad_weights.h" + +namespace webrtc { +namespace rnn_vad { +namespace test { + +using rnnoise::RectifiedLinearUnit; +using rnnoise::SigmoidApproximated; + +namespace { + +void TestFullyConnectedLayer(FullyConnectedLayer* fc, + rtc::ArrayView<const float> input_vector, + const float expected_output) { + RTC_CHECK(fc); + fc->ComputeOutput(input_vector); + const auto output = fc->GetOutput(); + EXPECT_NEAR(expected_output, output[0], 3e-6f); +} + +void TestGatedRecurrentLayer( + GatedRecurrentLayer* gru, + rtc::ArrayView<const float> input_sequence, + rtc::ArrayView<const float> expected_output_sequence) { + RTC_CHECK(gru); + auto gru_output_view = gru->GetOutput(); + const size_t input_sequence_length = + rtc::CheckedDivExact(input_sequence.size(), gru->input_size()); + const size_t output_sequence_length = + rtc::CheckedDivExact(expected_output_sequence.size(), gru->output_size()); + ASSERT_EQ(input_sequence_length, output_sequence_length) + << "The test data length is invalid."; + // Feed the GRU layer and check the output at every step. + gru->Reset(); + for (size_t i = 0; i < input_sequence_length; ++i) { + SCOPED_TRACE(i); + gru->ComputeOutput( + input_sequence.subview(i * gru->input_size(), gru->input_size())); + const auto expected_output = expected_output_sequence.subview( + i * gru->output_size(), gru->output_size()); + ExpectNearAbsolute(expected_output, gru_output_view, 3e-6f); + } +} + +} // namespace + +// Bit-exactness check for fully connected layers. +TEST(RnnVadTest, CheckFullyConnectedLayerOutput) { + const std::array<int8_t, 1> bias = {-50}; + const std::array<int8_t, 24> weights = { + 127, 127, 127, 127, 127, 20, 127, -126, -126, -54, 14, 125, + -126, -126, 127, -125, -126, 127, -127, -127, -57, -30, 127, 80}; + FullyConnectedLayer fc(24, 1, bias, weights, SigmoidApproximated); + // Test on different inputs. + { + const std::array<float, 24> input_vector = { + 0.f, 0.f, 0.f, 0.f, 0.f, + 0.f, 0.215833917f, 0.290601075f, 0.238759011f, 0.244751841f, + 0.f, 0.0461241305f, 0.106401242f, 0.223070428f, 0.630603909f, + 0.690453172f, 0.f, 0.387645692f, 0.166913897f, 0.f, + 0.0327451192f, 0.f, 0.136149868f, 0.446351469f}; + TestFullyConnectedLayer(&fc, {input_vector}, 0.436567038f); + } + { + const std::array<float, 24> input_vector = { + 0.592162728f, 0.529089332f, 1.18205106f, + 1.21736848f, 0.f, 0.470851123f, + 0.130675942f, 0.320903003f, 0.305496395f, + 0.0571633279f, 1.57001138f, 0.0182026215f, + 0.0977443159f, 0.347477973f, 0.493206412f, + 0.9688586f, 0.0320267938f, 0.244722098f, + 0.312745273f, 0.f, 0.00650715502f, + 0.312553257f, 1.62619662f, 0.782880902f}; + TestFullyConnectedLayer(&fc, {input_vector}, 0.874741316f); + } + { + const std::array<float, 24> input_vector = { + 0.395022154f, 0.333681047f, 0.76302278f, + 0.965480626f, 0.f, 0.941198349f, + 0.0892967582f, 0.745046318f, 0.635769248f, + 0.238564298f, 0.970656633f, 0.014159563f, + 0.094203949f, 0.446816623f, 0.640755892f, + 1.20532358f, 0.0254284926f, 0.283327013f, + 0.726210058f, 0.0550272502f, 0.000344108557f, + 0.369803518f, 1.56680179f, 0.997883797f}; + TestFullyConnectedLayer(&fc, {input_vector}, 0.672785878f); + } +} + +TEST(RnnVadTest, CheckGatedRecurrentLayer) { + const std::array<int8_t, 12> bias = {96, -99, -81, -114, 49, 119, + -118, 68, -76, 91, 121, 125}; + const std::array<int8_t, 60> weights = { + 124, 9, 1, 116, -66, -21, -118, -110, 104, 75, -23, -51, + -72, -111, 47, 93, 77, -98, 41, -8, 40, -23, -43, -107, + 9, -73, 30, -32, -2, 64, -26, 91, -48, -24, -28, -104, + 74, -46, 116, 15, 32, 52, -126, -38, -121, 12, -16, 110, + -95, 66, -103, -35, -38, 3, -126, -61, 28, 98, -117, -43}; + const std::array<int8_t, 60> recurrent_weights = { + -3, 87, 50, 51, -22, 27, -39, 62, 31, -83, -52, -48, + -6, 83, -19, 104, 105, 48, 23, 68, 23, 40, 7, -120, + 64, -62, 117, 85, -51, -43, 54, -105, 120, 56, -128, -107, + 39, 50, -17, -47, -117, 14, 108, 12, -7, -72, 103, -87, + -66, 82, 84, 100, -98, 102, -49, 44, 122, 106, -20, -69}; + GatedRecurrentLayer gru(5, 4, bias, weights, recurrent_weights, + RectifiedLinearUnit); + // Test on different inputs. + { + const std::array<float, 20> input_sequence = { + 0.89395463f, 0.93224651f, 0.55788344f, 0.32341808f, 0.93355054f, + 0.13475326f, 0.97370994f, 0.14253306f, 0.93710381f, 0.76093364f, + 0.65780413f, 0.41657975f, 0.49403164f, 0.46843281f, 0.75138855f, + 0.24517593f, 0.47657707f, 0.57064998f, 0.435184f, 0.19319285f}; + const std::array<float, 16> expected_output_sequence = { + 0.0239123f, 0.5773077f, 0.f, 0.f, + 0.01282811f, 0.64330572f, 0.f, 0.04863098f, + 0.00781069f, 0.75267816f, 0.f, 0.02579715f, + 0.00471378f, 0.59162533f, 0.11087593f, 0.01334511f}; + TestGatedRecurrentLayer(&gru, input_sequence, expected_output_sequence); + } +} + +// TODO(bugs.webrtc.org/9076): Remove when the issue is fixed. +// Bit-exactness test checking that precomputed frame-wise features lead to the +// expected VAD probabilities. +TEST(RnnVadTest, RnnBitExactness) { + // Init. + auto features_reader = CreateSilenceFlagsFeatureMatrixReader(); + auto vad_probs_reader = CreateVadProbsReader(); + ASSERT_EQ(features_reader.second, vad_probs_reader.second); + const size_t num_frames = features_reader.second; + // Frame-wise buffers. + float expected_vad_probability; + float is_silence; + std::array<float, kFeatureVectorSize> features; + + // Compute VAD probability using the precomputed features. + RnnBasedVad vad; + for (size_t i = 0; i < num_frames; ++i) { + SCOPED_TRACE(i); + // Read frame data. + RTC_CHECK(vad_probs_reader.first->ReadValue(&expected_vad_probability)); + // The features file also includes a silence flag for each frame. + RTC_CHECK(features_reader.first->ReadValue(&is_silence)); + RTC_CHECK( + features_reader.first->ReadChunk({features.data(), features.size()})); + // Skip silent frames. + ASSERT_TRUE(is_silence == 0.f || is_silence == 1.f); + if (is_silence == 1.f) { + ASSERT_EQ(expected_vad_probability, 0.f); + continue; + } + // Compute and check VAD probability. + vad.ComputeVadProbability({features.data(), features.size()}); + EXPECT_NEAR(expected_vad_probability, vad.vad_probability(), 3e-6f); + } +} + +} // namespace test +} // namespace rnn_vad +} // namespace webrtc |