chendl/compositional_test

1# coding=utf-82# Copyright 2021 HuggingFace Inc.3#4# Licensed under the Apache License, Version 2.0 (the "License");5# you may not use this file except in compliance with the License.6# You may obtain a copy of the License at7#8#     http://www.apache.org/licenses/LICENSE-2.09#10# Unless required by applicable law or agreed to in writing, software11# distributed under the License is distributed on an "AS IS" BASIS,12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13# See the License for the specific language governing permissions and14# limitations under the License.15 16 17import numpy as np18 19from transformers import BatchFeature20from transformers.testing_utils import require_tf, require_torch21 22from .test_feature_extraction_common import FeatureExtractionSavingTestMixin23 24 25class SequenceFeatureExtractionTestMixin(FeatureExtractionSavingTestMixin):26    # to overwrite at feature extractactor specific tests27    feat_extract_tester = None28    feature_extraction_class = None29 30    @property31    def feat_extract_dict(self):32        return self.feat_extract_tester.prepare_feat_extract_dict()33 34    def test_feat_extract_common_properties(self):35        feat_extract = self.feature_extraction_class(**self.feat_extract_dict)36        self.assertTrue(hasattr(feat_extract, "feature_size"))37        self.assertTrue(hasattr(feat_extract, "sampling_rate"))38        self.assertTrue(hasattr(feat_extract, "padding_value"))39 40    def test_batch_feature(self):41        speech_inputs = self.feat_extract_tester.prepare_inputs_for_common()42        feat_extract = self.feature_extraction_class(**self.feat_extract_dict)43        input_name = feat_extract.model_input_names[0]44 45        processed_features = BatchFeature({input_name: speech_inputs})46 47        self.assertTrue(all(len(x) == len(y) for x, y in zip(speech_inputs, processed_features[input_name])))48 49        speech_inputs = self.feat_extract_tester.prepare_inputs_for_common(equal_length=True)50        processed_features = BatchFeature({input_name: speech_inputs}, tensor_type="np")51 52        batch_features_input = processed_features[input_name]53 54        if len(batch_features_input.shape) < 3:55            batch_features_input = batch_features_input[:, :, None]56 57        self.assertTrue(58            batch_features_input.shape59            == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.feature_size)60        )61 62    @require_torch63    def test_batch_feature_pt(self):64        speech_inputs = self.feat_extract_tester.prepare_inputs_for_common(equal_length=True)65        feat_extract = self.feature_extraction_class(**self.feat_extract_dict)66        input_name = feat_extract.model_input_names[0]67 68        processed_features = BatchFeature({input_name: speech_inputs}, tensor_type="pt")69 70        batch_features_input = processed_features[input_name]71 72        if len(batch_features_input.shape) < 3:73            batch_features_input = batch_features_input[:, :, None]74 75        self.assertTrue(76            batch_features_input.shape77            == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.feature_size)78        )79 80    @require_tf81    def test_batch_feature_tf(self):82        speech_inputs = self.feat_extract_tester.prepare_inputs_for_common(equal_length=True)83        feat_extract = self.feature_extraction_class(**self.feat_extract_dict)84        input_name = feat_extract.model_input_names[0]85 86        processed_features = BatchFeature({input_name: speech_inputs}, tensor_type="tf")87 88        batch_features_input = processed_features[input_name]89 90        if len(batch_features_input.shape) < 3:91            batch_features_input = batch_features_input[:, :, None]92 93        self.assertTrue(94            batch_features_input.shape95            == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.feature_size)96        )97 98    def _check_padding(self, numpify=False):99        def _inputs_have_equal_length(input):100            length = len(input[0])101            for input_slice in input[1:]:102                if len(input_slice) != length:103                    return False104            return True105 106        def _inputs_are_equal(input_1, input_2):107            if len(input_1) != len(input_2):108                return False109 110            for input_slice_1, input_slice_2 in zip(input_1, input_2):111                if not np.allclose(np.asarray(input_slice_1), np.asarray(input_slice_2), atol=1e-3):112                    return False113            return True114 115        feat_extract = self.feature_extraction_class(**self.feat_extract_dict)116        speech_inputs = self.feat_extract_tester.prepare_inputs_for_common(numpify=numpify)117        input_name = feat_extract.model_input_names[0]118 119        processed_features = BatchFeature({input_name: speech_inputs})120 121        pad_diff = self.feat_extract_tester.seq_length_diff122        pad_max_length = self.feat_extract_tester.max_seq_length + pad_diff123        pad_min_length = self.feat_extract_tester.min_seq_length124        batch_size = self.feat_extract_tester.batch_size125        feature_size = self.feat_extract_tester.feature_size126 127        # test padding for List[int] + numpy128        input_1 = feat_extract.pad(processed_features, padding=False)129        input_1 = input_1[input_name]130 131        input_2 = feat_extract.pad(processed_features, padding="longest")132        input_2 = input_2[input_name]133 134        input_3 = feat_extract.pad(processed_features, padding="max_length", max_length=len(speech_inputs[-1]))135        input_3 = input_3[input_name]136 137        input_4 = feat_extract.pad(processed_features, padding="longest", return_tensors="np")138        input_4 = input_4[input_name]139 140        # max_length parameter has to be provided when setting `padding="max_length"`141        with self.assertRaises(ValueError):142            feat_extract.pad(processed_features, padding="max_length")[input_name]143 144        input_5 = feat_extract.pad(145            processed_features, padding="max_length", max_length=pad_max_length, return_tensors="np"146        )147        input_5 = input_5[input_name]148 149        self.assertFalse(_inputs_have_equal_length(input_1))150        self.assertTrue(_inputs_have_equal_length(input_2))151        self.assertTrue(_inputs_have_equal_length(input_3))152        self.assertTrue(_inputs_are_equal(input_2, input_3))153        self.assertTrue(len(input_1[0]) == pad_min_length)154        self.assertTrue(len(input_1[1]) == pad_min_length + pad_diff)155        self.assertTrue(input_4.shape[:2] == (batch_size, len(input_3[0])))156        self.assertTrue(input_5.shape[:2] == (batch_size, pad_max_length))157 158        if feature_size > 1:159            self.assertTrue(input_4.shape[2] == input_5.shape[2] == feature_size)160 161        # test padding for `pad_to_multiple_of` for List[int] + numpy162        input_6 = feat_extract.pad(processed_features, pad_to_multiple_of=10)163        input_6 = input_6[input_name]164 165        input_7 = feat_extract.pad(processed_features, padding="longest", pad_to_multiple_of=10)166        input_7 = input_7[input_name]167 168        input_8 = feat_extract.pad(169            processed_features, padding="max_length", pad_to_multiple_of=10, max_length=pad_max_length170        )171        input_8 = input_8[input_name]172 173        input_9 = feat_extract.pad(174            processed_features,175            padding="max_length",176            pad_to_multiple_of=10,177            max_length=pad_max_length,178            return_tensors="np",179        )180        input_9 = input_9[input_name]181 182        self.assertTrue(all(len(x) % 10 == 0 for x in input_6))183        self.assertTrue(_inputs_are_equal(input_6, input_7))184 185        expected_mult_pad_length = pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10186        self.assertTrue(all(len(x) == expected_mult_pad_length for x in input_8))187        self.assertEqual(input_9.shape[:2], (batch_size, expected_mult_pad_length))188 189        if feature_size > 1:190            self.assertTrue(input_9.shape[2] == feature_size)191 192        # Check padding value is correct193        padding_vector_sum = (np.ones(self.feat_extract_tester.feature_size) * feat_extract.padding_value).sum()194        self.assertTrue(195            abs(np.asarray(input_2[0])[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length))196            < 1e-3197        )198        self.assertTrue(199            abs(200                np.asarray(input_2[1])[pad_min_length + pad_diff :].sum()201                - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)202            )203            < 1e-3204        )205        self.assertTrue(206            abs(207                np.asarray(input_2[2])[pad_min_length + 2 * pad_diff :].sum()208                - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)209            )210            < 1e-3211        )212        self.assertTrue(213            abs(input_5[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)) < 1e-3214        )215        self.assertTrue(216            abs(input_9[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length))217            < 1e-3218        )219 220    def _check_truncation(self, numpify=False):221        def _inputs_have_equal_length(input):222            length = len(input[0])223            for input_slice in input[1:]:224                if len(input_slice) != length:225                    return False226            return True227 228        def _inputs_are_equal(input_1, input_2):229            if len(input_1) != len(input_2):230                return False231 232            for input_slice_1, input_slice_2 in zip(input_1, input_2):233                if not np.allclose(np.asarray(input_slice_1), np.asarray(input_slice_2), atol=1e-3):234                    return False235            return True236 237        feat_extract = self.feature_extraction_class(**self.feat_extract_dict)238        speech_inputs = self.feat_extract_tester.prepare_inputs_for_common(numpify=numpify)239        input_name = feat_extract.model_input_names[0]240 241        processed_features = BatchFeature({input_name: speech_inputs})242 243        # truncate to smallest244        input_1 = feat_extract.pad(245            processed_features, padding="max_length", max_length=len(speech_inputs[0]), truncation=True246        )247        input_1 = input_1[input_name]248 249        input_2 = feat_extract.pad(processed_features, padding="max_length", max_length=len(speech_inputs[0]))250        input_2 = input_2[input_name]251 252        self.assertTrue(_inputs_have_equal_length(input_1))253        self.assertFalse(_inputs_have_equal_length(input_2))254 255        # truncate to smallest with np256        input_3 = feat_extract.pad(257            processed_features,258            padding="max_length",259            max_length=len(speech_inputs[0]),260            return_tensors="np",261            truncation=True,262        )263        input_3 = input_3[input_name]264 265        input_4 = feat_extract.pad(266            processed_features, padding="max_length", max_length=len(speech_inputs[0]), return_tensors="np"267        )268        input_4 = input_4[input_name]269 270        self.assertTrue(_inputs_have_equal_length(input_3))271        self.assertTrue(input_3.shape[1] == len(speech_inputs[0]))272 273        # since truncation forces padding to be smaller than longest input274        # function can't return `np.ndarray`, but has to return list275        self.assertFalse(_inputs_have_equal_length(input_4))276 277        # truncate to middle278        input_5 = feat_extract.pad(279            processed_features,280            padding="max_length",281            max_length=len(speech_inputs[1]),282            truncation=True,283            return_tensors="np",284        )285        input_5 = input_5[input_name]286 287        input_6 = feat_extract.pad(288            processed_features, padding="max_length", max_length=len(speech_inputs[1]), truncation=True289        )290        input_6 = input_6[input_name]291 292        input_7 = feat_extract.pad(293            processed_features, padding="max_length", max_length=len(speech_inputs[1]), return_tensors="np"294        )295        input_7 = input_7[input_name]296 297        self.assertTrue(input_5.shape[1] == len(speech_inputs[1]))298        self.assertTrue(_inputs_have_equal_length(input_5))299        self.assertTrue(_inputs_have_equal_length(input_6))300        self.assertTrue(_inputs_are_equal(input_5, input_6))301 302        # since truncation forces padding to be smaller than longest input303        # function can't return `np.ndarray`, but has to return list304        self.assertFalse(_inputs_have_equal_length(input_7))305        self.assertTrue(len(input_7[-1]) == len(speech_inputs[-1]))306 307        # padding has to be max_length when setting `truncation=True`308        with self.assertRaises(ValueError):309            feat_extract.pad(processed_features, truncation=True)[input_name]310 311        # padding has to be max_length when setting `truncation=True`312        with self.assertRaises(ValueError):313            feat_extract.pad(processed_features, padding="longest", truncation=True)[input_name]314 315        # padding has to be max_length when setting `truncation=True`316        with self.assertRaises(ValueError):317            feat_extract.pad(processed_features, padding="longest", truncation=True)[input_name]318 319        # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"320        with self.assertRaises(ValueError):321            feat_extract.pad(processed_features, padding="max_length", truncation=True)[input_name]322 323        # test truncation for `pad_to_multiple_of` for List[int] + numpy324        pad_to_multiple_of = 12325        input_8 = feat_extract.pad(326            processed_features,327            padding="max_length",328            max_length=len(speech_inputs[0]),329            pad_to_multiple_of=pad_to_multiple_of,330            truncation=True,331        )332        input_8 = input_8[input_name]333 334        input_9 = feat_extract.pad(335            processed_features,336            padding="max_length",337            max_length=len(speech_inputs[0]),338            pad_to_multiple_of=pad_to_multiple_of,339        )340        input_9 = input_9[input_name]341 342        # retrieve expected_length as multiple of pad_to_multiple_of343        expected_length = len(speech_inputs[0])344        if expected_length % pad_to_multiple_of != 0:345            expected_length = ((len(speech_inputs[0]) // pad_to_multiple_of) + 1) * pad_to_multiple_of346 347        self.assertTrue(len(input_8[0]) == expected_length)348        self.assertTrue(_inputs_have_equal_length(input_8))349        self.assertFalse(_inputs_have_equal_length(input_9))350 351    def test_padding_from_list(self):352        self._check_padding(numpify=False)353 354    def test_padding_from_array(self):355        self._check_padding(numpify=True)356 357    def test_truncation_from_list(self):358        self._check_truncation(numpify=False)359 360    def test_truncation_from_array(self):361        self._check_truncation(numpify=True)362 363    @require_torch364    def test_padding_accepts_tensors_pt(self):365        feat_extract = self.feature_extraction_class(**self.feat_extract_dict)366        speech_inputs = self.feat_extract_tester.prepare_inputs_for_common()367        input_name = feat_extract.model_input_names[0]368 369        processed_features = BatchFeature({input_name: speech_inputs})370 371        input_np = feat_extract.pad(processed_features, padding="longest", return_tensors="np")[input_name]372        input_pt = feat_extract.pad(processed_features, padding="longest", return_tensors="pt")[input_name]373 374        self.assertTrue(abs(input_np.astype(np.float32).sum() - input_pt.numpy().astype(np.float32).sum()) < 1e-2)375 376    @require_tf377    def test_padding_accepts_tensors_tf(self):378        feat_extract = self.feature_extraction_class(**self.feat_extract_dict)379        speech_inputs = self.feat_extract_tester.prepare_inputs_for_common()380        input_name = feat_extract.model_input_names[0]381 382        processed_features = BatchFeature({input_name: speech_inputs})383 384        input_np = feat_extract.pad(processed_features, padding="longest", return_tensors="np")[input_name]385        input_tf = feat_extract.pad(processed_features, padding="longest", return_tensors="tf")[input_name]386 387        self.assertTrue(abs(input_np.astype(np.float32).sum() - input_tf.numpy().astype(np.float32).sum()) < 1e-2)388 389    def test_attention_mask(self):390        feat_dict = self.feat_extract_dict391        feat_dict["return_attention_mask"] = True392        feat_extract = self.feature_extraction_class(**feat_dict)393        speech_inputs = self.feat_extract_tester.prepare_inputs_for_common()394        input_lenghts = [len(x) for x in speech_inputs]395        input_name = feat_extract.model_input_names[0]396 397        processed = BatchFeature({input_name: speech_inputs})398 399        processed = feat_extract.pad(processed, padding="longest", return_tensors="np")400        self.assertIn("attention_mask", processed)401        self.assertListEqual(list(processed.attention_mask.shape), list(processed[input_name].shape[:2]))402        self.assertListEqual(processed.attention_mask.sum(-1).tolist(), input_lenghts)403 404    def test_attention_mask_with_truncation(self):405        feat_dict = self.feat_extract_dict406        feat_dict["return_attention_mask"] = True407        feat_extract = self.feature_extraction_class(**feat_dict)408        speech_inputs = self.feat_extract_tester.prepare_inputs_for_common()409        input_lenghts = [len(x) for x in speech_inputs]410        input_name = feat_extract.model_input_names[0]411 412        processed = BatchFeature({input_name: speech_inputs})413        max_length = min(input_lenghts)414 415        processed_pad = feat_extract.pad(416            processed, padding="max_length", max_length=max_length, truncation=True, return_tensors="np"417        )418        self.assertIn("attention_mask", processed_pad)419        self.assertListEqual(420            list(processed_pad.attention_mask.shape), [processed_pad[input_name].shape[0], max_length]421        )422        self.assertListEqual(423            processed_pad.attention_mask[:, :max_length].sum(-1).tolist(), [max_length for x in speech_inputs]424        )425