




import torch
from transformers import PreTrainedModel, XLMRobertaConfig, XLMRobertaModel
class     a__					(      snake_case__   ):
						_a							:					Optional[Any]      =					"""M-CLIP"""






						def __init__(     self	,    _A=1_0_2_4	,    _A=7_6_8	,    **_A    ):




											"""simple docstring"""



											__lowerCAmelCase            = transformerDimSize
											__lowerCAmelCase            = imageDimSize
											super().__init__(**_A    )






class     a__					(      snake_case__   ):
						_a							:					Tuple      =					MCLIPConfig






						def __init__(     self	,    _A	,    *_A	,    **_A    ):




											"""simple docstring"""



											super().__init__(_A	,    *_A	,    **_A    )
											__lowerCAmelCase            = XLMRobertaModel(_A    )
											__lowerCAmelCase            = torch.nn.Linear(
											    in_features=config.transformerDimensions	,    out_features=config.numDims    )






						def        __SCREAMING_SNAKE_CASE(     self	,    _A	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.transformer(input_ids=_A	,    attention_mask=_A    )[0]
											__lowerCAmelCase            = (embs * attention_mask.unsqueeze(2    )).sum(dim=1    ) / attention_mask.sum(dim=1    )[:, None]
											return self.LinearTransformation(_A    ), embs










import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
					from transformers import SpeechaTextFeatureExtractor

UpperCamelCase__					    =    random.Random()







def 			_a   (		SCREAMING_SNAKE_CASE_							:       Union[str, Any]   ,   SCREAMING_SNAKE_CASE_							:       Union[str, Any]=1.0   ,   SCREAMING_SNAKE_CASE_							:       Any=None   ,   SCREAMING_SNAKE_CASE_							:       Any=None  ):
					if rng is None:
										__lowerCAmelCase            = global_rng

					__lowerCAmelCase            = []
					for batch_idx in range(shape[0]  ):
										values.append([]  )
										for _ in range(shape[1]  ):
															values[-1].append(rng.random() * scale  )

					return values
@require_torch
@require_torchaudio
class     a__					(      unittest.TestCase   ):






						def __init__(     self	,    _A	,    _A=7	,    _A=4_0_0	,    _A=2_0_0_0	,    _A=2_4	,    _A=2_4	,    _A=0.0	,    _A=1_6_0_0_0	,    _A=True	,    _A=True	,    ):




											"""simple docstring"""



											__lowerCAmelCase            = parent
											__lowerCAmelCase            = batch_size
											__lowerCAmelCase            = min_seq_length
											__lowerCAmelCase            = max_seq_length
											__lowerCAmelCase            = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
											__lowerCAmelCase            = feature_size
											__lowerCAmelCase            = num_mel_bins
											__lowerCAmelCase            = padding_value
											__lowerCAmelCase            = sampling_rate
											__lowerCAmelCase            = return_attention_mask
											__lowerCAmelCase            = do_normalize






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											return {
											    "feature_size": self.feature_size,
											    "num_mel_bins": self.num_mel_bins,
											    "padding_value": self.padding_value,
											    "sampling_rate": self.sampling_rate,
											    "return_attention_mask": self.return_attention_mask,
											    "do_normalize": self.do_normalize,
											}






						def        __SCREAMING_SNAKE_CASE(     self	,    _A=False	,    _A=False    ):




											"""simple docstring"""



											def _flatten(_A    ):
																return list(itertools.chain(*_A    )    )

											if equal_length:
																__lowerCAmelCase            = [floats_list((self.max_seq_length, self.feature_size)    ) for _ in range(self.batch_size    )]
											else:
																# make sure that inputs increase in size
																__lowerCAmelCase            = [
																    floats_list((x, self.feature_size)    )
																    for x in range(self.min_seq_length	,    self.max_seq_length	,    self.seq_length_diff    )
																]
											if numpify:
																__lowerCAmelCase            = [np.asarray(_A    ) for x in speech_inputs]
											return speech_inputs






@require_torch
@require_torchaudio
class     a__					(      snake_case__				,       unittest.TestCase   ):
						_a							:					Optional[int]      =					SpeechaTextFeatureExtractor if is_speech_available() else None






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = SpeechaTextFeatureExtractionTester(self    )






						def        __SCREAMING_SNAKE_CASE(     self	,    _A    ):




											"""simple docstring"""



											self.assertTrue(np.all(np.mean(_A	,    axis=0    ) < 1E-3    )    )
											self.assertTrue(np.all(np.abs(np.var(_A	,    axis=0    ) - 1    ) < 1E-3    )    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											# create three inputs of length 800, 1000, and 1200
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]
											__lowerCAmelCase            = [np.asarray(_A    ) for speech_input in speech_inputs]

											# Test feature size
											__lowerCAmelCase            = feature_extractor(_A	,    padding=_A	,    return_tensors="np"    ).input_features
											self.assertTrue(input_features.ndim == 3    )
											self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size    )

											# Test not batched input
											__lowerCAmelCase            = feature_extractor(speech_inputs[0]	,    return_tensors="np"    ).input_features
											__lowerCAmelCase            = feature_extractor(np_speech_inputs[0]	,    return_tensors="np"    ).input_features
											self.assertTrue(np.allclose(_A	,    _A	,    atol=1E-3    )    )

											# Test batched
											__lowerCAmelCase            = feature_extractor(_A	,    return_tensors="np"    ).input_features
											__lowerCAmelCase            = feature_extractor(_A	,    return_tensors="np"    ).input_features
											for enc_seq_a, enc_seq_a in zip(_A	,    _A    ):
																self.assertTrue(np.allclose(_A	,    _A	,    atol=1E-3    )    )

											# Test 2-D numpy arrays are batched.
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in (8_0_0, 8_0_0, 8_0_0)]
											__lowerCAmelCase            = np.asarray(_A    )
											__lowerCAmelCase            = feature_extractor(_A	,    return_tensors="np"    ).input_features
											__lowerCAmelCase            = feature_extractor(_A	,    return_tensors="np"    ).input_features
											for enc_seq_a, enc_seq_a in zip(_A	,    _A    ):
																self.assertTrue(np.allclose(_A	,    _A	,    atol=1E-3    )    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]

											__lowerCAmelCase            = ["longest", "max_length", "do_not_pad"]
											__lowerCAmelCase            = [None, 1_6, None]
											for max_length, padding in zip(_A	,    _A    ):
																__lowerCAmelCase            = feature_extractor(
																    _A	,    padding=_A	,    max_length=_A	,    return_attention_mask=_A    )
																__lowerCAmelCase            = inputs.input_features
																__lowerCAmelCase            = inputs.attention_mask
																__lowerCAmelCase            = [np.sum(_A    ) for x in attention_mask]

																self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]    )
																self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]    )
																self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]

											__lowerCAmelCase            = ["longest", "max_length", "do_not_pad"]
											__lowerCAmelCase            = [None, 1_6, None]
											for max_length, padding in zip(_A	,    _A    ):
																__lowerCAmelCase            = feature_extractor(
																    _A	,    max_length=_A	,    padding=_A	,    return_tensors="np"	,    return_attention_mask=_A    )
																__lowerCAmelCase            = inputs.input_features
																__lowerCAmelCase            = inputs.attention_mask
																__lowerCAmelCase            = [np.sum(_A    ) for x in attention_mask]

																self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]    )
																self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1E-6    )
																self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]    )
																self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1E-6    )
																self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]
											__lowerCAmelCase            = feature_extractor(
											    _A	,    padding="max_length"	,    max_length=4	,    truncation=_A	,    return_tensors="np"	,    return_attention_mask=_A	,    )
											__lowerCAmelCase            = inputs.input_features
											__lowerCAmelCase            = inputs.attention_mask
											__lowerCAmelCase            = np.sum(attention_mask == 1	,    axis=1    )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
											self._check_zero_mean_unit_variance(input_features[1]    )
											self._check_zero_mean_unit_variance(input_features[2]    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]
											__lowerCAmelCase            = feature_extractor(
											    _A	,    padding="longest"	,    max_length=4	,    truncation=_A	,    return_tensors="np"	,    return_attention_mask=_A	,    )
											__lowerCAmelCase            = inputs.input_features
											__lowerCAmelCase            = inputs.attention_mask
											__lowerCAmelCase            = np.sum(attention_mask == 1	,    axis=1    )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
											self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]    )
											self._check_zero_mean_unit_variance(input_features[2]    )

											# make sure that if max_length < longest -> then pad to max_length
											self.assertEqual(input_features.shape	,    (3, 4, 2_4)    )

											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]
											__lowerCAmelCase            = feature_extractor(
											    _A	,    padding="longest"	,    max_length=1_6	,    truncation=_A	,    return_tensors="np"	,    return_attention_mask=_A	,    )
											__lowerCAmelCase            = inputs.input_features
											__lowerCAmelCase            = inputs.attention_mask
											__lowerCAmelCase            = np.sum(attention_mask == 1	,    axis=1    )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
											self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]    )
											self._check_zero_mean_unit_variance(input_features[2]    )

											# make sure that if max_length < longest -> then pad to max_length
											self.assertEqual(input_features.shape	,    (3, 6, 2_4)    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											import torch

											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = np.random.rand(1_0_0	,    3_2    ).astype(np.floataa    )
											__lowerCAmelCase            = np_speech_inputs.tolist()

											for inputs in [py_speech_inputs, np_speech_inputs]:
																__lowerCAmelCase            = feature_extractor.pad([{"input_features": inputs}]	,    return_tensors="np"    )
																self.assertTrue(np_processed.input_features.dtype == np.floataa    )
																__lowerCAmelCase            = feature_extractor.pad([{"input_features": inputs}]	,    return_tensors="pt"    )
																self.assertTrue(pt_processed.input_features.dtype == torch.floataa    )






						def        __SCREAMING_SNAKE_CASE(     self	,    _A    ):




											"""simple docstring"""



											from datasets import load_dataset

											__lowerCAmelCase            = load_dataset("hf-internal-testing/librispeech_asr_dummy"	,    "clean"	,    split="validation"    )
											# automatic decoding with librispeech
											__lowerCAmelCase            = ds.sort("id"    ).select(range(_A    )    )[:num_samples]["audio"]

											return [x["array"] for x in speech_samples]






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = np.array([
											    -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
											    -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
											    -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
											]    )
											# fmt: on

											__lowerCAmelCase            = self._load_datasamples(1    )
											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = feature_extractor(_A	,    return_tensors="pt"    ).input_features
											self.assertEquals(input_features.shape	,    (1, 5_8_4, 2_4)    )
											self.assertTrue(np.allclose(input_features[0, 0, :3_0]	,    _A	,    atol=1E-4    )    )




