AC: Added ovelapping while clipping audio (openvinotoolkit#1160)

* Ovelapping while clipping audio

* Delete confusing redundant parameters

* Values 'duration' and 'overlap' processing extract to methods

Author: eizamaliev

tools/accuracy_checker/accuracy_checker/preprocessor/README.md

@@ -122,8 +122,9 @@ Accuracy Checker supports following set of preprocessors:
 * `resample_audio` - converts audio to new sample rate
   * `sample_rate` - sets new sample rate
 * `clip_audio` - slices audio into several parts with equal duration
-  * `duration` - sets duration in seconds
-  * `max_clips` - sets the maximum number of clips (by default `1`)
+  * `duration` - sets duration of each clip in seconds or samples (use `samples` suffix), e.g. `1.5`, `16000samples`
+  * `overlap` - sets overlapping for clips in percents or samples (use `%` or `samples` suffixes respectively) (no overlapping by default), e.g. `25%`, `4000samples`
+  * `max_clips` - sets the maximum number of clips (clips all record by default)
 * `audio_normalization` - normalize audio record with mean sample subtraction and division on standard deviation of samples.
 * `similarity_transform_box` - apply to image similarity transformation to get rectangle region stored in annotation metadata/
     * `box_scale` - box scale factor (Optional, default 1).

tools/accuracy_checker/accuracy_checker/preprocessor/audio_preprocessing.py

@@ -16,7 +16,7 @@
 
 import numpy as np
 
-from ..config import NumberField
+from ..config import BaseField, NumberField, ConfigError
 from ..preprocessor import Preprocessor
 
 
@@ -64,20 +64,28 @@ class ClipAudio(Preprocessor):
     def parameters(cls):
         parameters = super().parameters()
         parameters.update({
-            'duration': NumberField(
-                value_type=int, min_value=0,
-                description="Length of audio clip in seconds."
+            'duration': BaseField(
+                description="Length of audio clip in seconds or samples (with 'samples' suffix)."
             ),
             'max_clips': NumberField(
-                value_type=int, min_value=1, default=1,
+                value_type=int, min_value=1, optional=True,
                 description="Maximum number of clips per audiofile."
             ),
+            'overlap': BaseField(
+                optional=True,
+                description="Overlapping part for each clip."
+            ),
         })
         return parameters
 
     def configure(self):
-        self.duration = self.get_value_from_config('duration')
-        self.max_clips = self.get_value_from_config('max_clips')
+        duration = self.get_value_from_config('duration')
+        self._parse_duration(duration)
+
+        self.max_clips = self.get_value_from_config('max_clips') or np.inf
+
+        overlap = self.get_value_from_config('overlap')
+        self._parse_overlap(overlap)
 
     def process(self, image, annotation_meta=None):
         data = image.data
@@ -86,18 +94,86 @@ def process(self, image, annotation_meta=None):
             raise RuntimeError('Operation "{}" failed: required "sample rate" in metadata.'.
                                format(self.__provider__))
         audio_duration = data.shape[1]
-        clip_duration = self.duration * sample_rate
+        clip_duration = self.duration if self.is_duration_in_samples else int(self.duration * sample_rate)
         clipped_data = []
-        for i in range(self.max_clips):
-            if (i + 1) * clip_duration > audio_duration:
+        if self.is_overlap_in_samples:
+            hop = clip_duration - self.overlap_in_samples
+        else:
+            hop = int((1 - self.overlap) * clip_duration)
+
+        if hop > clip_duration:
+            raise ConfigError("Preprocessor {}: clip overlapping exceeds clip length.".format(self.__provider__))
+
+        for clip_no, clip_start in enumerate(range(0, audio_duration, hop)):
+            if clip_start + clip_duration > audio_duration or clip_no >= self.max_clips:
                 break
-            clip = data[:, i * clip_duration: (i+1) * clip_duration]
+            clip = data[:, clip_start: clip_start + clip_duration]
             clipped_data.append(clip)
+
         image.data = clipped_data
         image.metadata['multi_infer'] = True
 
         return image
 
+    def _parse_overlap(self, overlap):
+        self.is_overlap_in_samples = False
+        self.overlap = 0
+        if isinstance(overlap, str):
+            if overlap.endswith('%'):
+                try:
+                    self.overlap = float(overlap[:-1]) / 100
+                except ValueError:
+                    raise ConfigError("Preprocessor {}: invalid value for 'overlap' - {}."
+                                      .format(self.__provider__, overlap))
+            elif overlap.endswith('samples'):
+                try:
+                    self.overlap_in_samples = int(overlap[:-7])
+                except ValueError:
+                    raise ConfigError("Preprocessor {}: invalid value for 'overlap' - {}."
+                                      .format(self.__provider__, overlap))
+                if self.overlap_in_samples < 1:
+                    raise ConfigError("Preprocessor {}: invalid value for 'overlap' - {}."
+                                      .format(self.__provider__, overlap))
+                self.is_overlap_in_samples = True
+            else:
+                raise ConfigError("Preprocessor {}: invalid value for 'overlap' - {}."
+                                  .format(self.__provider__, overlap))
+        else:
+            try:
+                self.overlap = float(overlap)
+            except ValueError:
+                raise ConfigError("Preprocessor {}: invalid value for 'overlap' - {}."
+                                  .format(self.__provider__, overlap))
+            if self.overlap <= 0 or self.overlap >= 1:
+                raise ConfigError("Preprocessor {}: invalid value for 'overlap' - {}."
+                                  .format(self.__provider__, overlap))
+
+    def _parse_duration(self, duration):
+        self.is_duration_in_samples = False
+        if isinstance(duration, str):
+            if duration.endswith('samples'):
+                try:
+                    self.duration = int(duration[:-7])
+                except ValueError:
+                    raise ConfigError("Preprocessor {}: invalid value for duration - {}."
+                                      .format(self.__provider__, duration))
+                if self.duration <= 1:
+                    raise ConfigError("Preprocessor {}: duration should be positive value - {}."
+                                      .format(self.__provider__, self.duration))
+                self.is_duration_in_samples = True
+            else:
+                raise ConfigError("Preprocessor {}: invalid value for duration - {}.".
+                                  format(self.__provider__, duration))
+        else:
+            try:
+                self.duration = float(duration)
+            except ValueError:
+                raise ConfigError("Preprocessor {}: invalid value for duration - {}."
+                                  .format(self.__provider__, duration))
+            if self.duration <= 0:
+                raise ConfigError("Preprocessor {}: duration should be positive value - {}."
+                                  .format(self.__provider__, self.duration))
+
 
 class NormalizeAudio(Preprocessor):
     __provider__ = 'audio_normalization'