


import json
import os
import shutil
import tempfile
import unittest

import numpy as np

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer
from transformers.testing_utils import require_tokenizers, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
     from PIL import Image

     from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor







@require_tokenizers
@require_vision
class 						_snake_case    ( unittest.TestCase				):




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Dict									=			tempfile.mkdtemp()

       # fmt: off
       a		:int									=			['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''', ''',''', '''low''', '''lowest''']
       # fmt: on
       a		:Optional[Any]									=			os.path.join(self.tmpdirname   ,    VOCAB_FILES_NAMES['''vocab_file''']       )
       with open(self.vocab_file   ,    '''w'''   ,    encoding='''utf-8'''       ) as vocab_writer:
             vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]       )       )

       a		:Any									=			{
           '''do_resize''': True,
           '''size''': {'''height''': 18, '''width''': 18},
           '''do_normalize''': True,
           '''image_mean''': [0.5, 0.5, 0.5],
           '''image_std''': [0.5, 0.5, 0.5],
       }
       a		:Union[str, Any]									=			os.path.join(self.tmpdirname   ,    _lowerCamelCase       )
       with open(self.image_processor_file   ,    '''w'''   ,    encoding='''utf-8'''       ) as fp:
             json.dump(_lowerCamelCase   ,    _lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    **_lowerCamelCase       ):
       return BertTokenizer.from_pretrained(self.tmpdirname   ,    **_lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    **_lowerCamelCase       ):
       return ViTImageProcessor.from_pretrained(self.tmpdirname   ,    **_lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       shutil.rmtree(self.tmpdirname       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:int									=			[np.random.randint(255   ,    size=(3, 30, 400)   ,    dtype=np.uinta       )]

       a		:Optional[Any]									=			[Image.fromarray(np.moveaxis(_lowerCamelCase   ,    0   ,    -1       )       ) for x in image_inputs]

       return image_inputs




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Any									=			self.get_tokenizer()
       a		:Union[str, Any]									=			self.get_image_processor()

       a		:str									=			VisionTextDualEncoderProcessor(tokenizer=_lowerCamelCase   ,    image_processor=_lowerCamelCase       )

       processor.save_pretrained(self.tmpdirname       )
       a		:Union[str, Any]									=			VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname       )

       self.assertEqual(processor.tokenizer.get_vocab()   ,    tokenizer.get_vocab()       )
       self.assertIsInstance(processor.tokenizer   ,    (BertTokenizer, BertTokenizerFast)       )

       self.assertEqual(processor.image_processor.to_json_string()   ,    image_processor.to_json_string()       )
       self.assertIsInstance(processor.image_processor   ,    _lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:List[Any]									=			VisionTextDualEncoderProcessor(
           tokenizer=self.get_tokenizer()   ,    image_processor=self.get_image_processor()       )
       processor.save_pretrained(self.tmpdirname       )

       a		:Dict									=			self.get_tokenizer(bos_token='''(BOS)'''   ,    eos_token='''(EOS)'''       )
       a		:List[str]									=			self.get_image_processor(do_normalize=_lowerCamelCase   ,    padding_value=1.0       )

       a		:List[Any]									=			VisionTextDualEncoderProcessor.from_pretrained(
           self.tmpdirname   ,    bos_token='''(BOS)'''   ,    eos_token='''(EOS)'''   ,    do_normalize=_lowerCamelCase   ,    padding_value=1.0       )

       self.assertEqual(processor.tokenizer.get_vocab()   ,    tokenizer_add_kwargs.get_vocab()       )
       self.assertIsInstance(processor.tokenizer   ,    (BertTokenizer, BertTokenizerFast)       )

       self.assertEqual(processor.image_processor.to_json_string()   ,    image_processor_add_kwargs.to_json_string()       )
       self.assertIsInstance(processor.image_processor   ,    _lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:List[str]									=			self.get_image_processor()
       a		:Dict									=			self.get_tokenizer()

       a		:Tuple									=			VisionTextDualEncoderProcessor(tokenizer=_lowerCamelCase   ,    image_processor=_lowerCamelCase       )

       a		:Dict									=			self.prepare_image_inputs()

       a		:str									=			image_processor(_lowerCamelCase   ,    return_tensors='''np'''       )
       a		:int									=			processor(images=_lowerCamelCase   ,    return_tensors='''np'''       )

       for key in input_feat_extract.keys():
             self.assertAlmostEqual(input_feat_extract[key].sum()   ,    input_processor[key].sum()   ,    delta=1e-2       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Tuple									=			self.get_image_processor()
       a		:Optional[int]									=			self.get_tokenizer()

       a		:Any									=			VisionTextDualEncoderProcessor(tokenizer=_lowerCamelCase   ,    image_processor=_lowerCamelCase       )

       a		:str									=			'''lower newer'''

       a		:List[str]									=			processor(text=_lowerCamelCase       )

       a		:Optional[Any]									=			tokenizer(_lowerCamelCase       )

       for key in encoded_tok.keys():
             self.assertListEqual(encoded_tok[key]   ,    encoded_processor[key]       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Any									=			self.get_image_processor()
       a		:int									=			self.get_tokenizer()

       a		:Optional[int]									=			VisionTextDualEncoderProcessor(tokenizer=_lowerCamelCase   ,    image_processor=_lowerCamelCase       )

       a		:Union[str, Any]									=			'''lower newer'''
       a		:Dict									=			self.prepare_image_inputs()

       a		:Optional[int]									=			processor(text=_lowerCamelCase   ,    images=_lowerCamelCase       )

       self.assertListEqual(list(inputs.keys()       )   ,    ['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']       )

       # test if it raises when no input is passed
       with self.assertRaises(_lowerCamelCase       ):
             processor()




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:Optional[Any]									=			self.get_image_processor()
       a		:Optional[int]									=			self.get_tokenizer()

       a		:str									=			VisionTextDualEncoderProcessor(tokenizer=_lowerCamelCase   ,    image_processor=_lowerCamelCase       )

       a		:Optional[int]									=			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

       a		:Optional[Any]									=			processor.batch_decode(_lowerCamelCase       )
       a		:List[Any]									=			tokenizer.batch_decode(_lowerCamelCase       )

       self.assertListEqual(_lowerCamelCase   ,    _lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       a		:List[str]									=			self.get_image_processor()
       a		:Dict									=			self.get_tokenizer()

       a		:str									=			VisionTextDualEncoderProcessor(tokenizer=_lowerCamelCase   ,    image_processor=_lowerCamelCase       )

       a		:Dict									=			'''lower newer'''
       a		:Dict									=			self.prepare_image_inputs()

       a		:List[Any]									=			processor(text=_lowerCamelCase   ,    images=_lowerCamelCase       )

       self.assertListEqual(list(inputs.keys()       )   ,    processor.model_input_names       )









import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


snake_case							:       Optional[int]										=	logging.get_logger(__name__)

snake_case							:       Optional[int]										=	{
    '''microsoft/unispeech-large-1500h-cv''': (
        '''https://huggingface.co/microsoft/unispeech-large-1500h-cv/resolve/main/config.json'''
    ),
    # See all UniSpeech models at https://huggingface.co/models?filter=unispeech
}







class 						_snake_case    ( _snake_case				):
 SCREAMING_SNAKE_CASE__ =			'unispeech'




 def __init__(						self   ,    _lowerCamelCase=32   ,    _lowerCamelCase=768   ,    _lowerCamelCase=12   ,    _lowerCamelCase=12   ,    _lowerCamelCase=3072   ,    _lowerCamelCase="gelu"   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.0   ,    _lowerCamelCase=0.0   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.02   ,    _lowerCamelCase=1e-5   ,    _lowerCamelCase="group"   ,    _lowerCamelCase="gelu"   ,    _lowerCamelCase=(512, 512, 512, 512, 512, 512, 512)   ,    _lowerCamelCase=(5, 2, 2, 2, 2, 2, 2)   ,    _lowerCamelCase=(10, 3, 3, 3, 3, 2, 2)   ,    _lowerCamelCase=False   ,    _lowerCamelCase=128   ,    _lowerCamelCase=16   ,    _lowerCamelCase=False   ,    _lowerCamelCase=True   ,    _lowerCamelCase=0.05   ,    _lowerCamelCase=10   ,    _lowerCamelCase=2   ,    _lowerCamelCase=0.0   ,    _lowerCamelCase=10   ,    _lowerCamelCase=0   ,    _lowerCamelCase=320   ,    _lowerCamelCase=2   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=100   ,    _lowerCamelCase=256   ,    _lowerCamelCase=256   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase="mean"   ,    _lowerCamelCase=False   ,    _lowerCamelCase=False   ,    _lowerCamelCase=256   ,    _lowerCamelCase=80   ,    _lowerCamelCase=0   ,    _lowerCamelCase=1   ,    _lowerCamelCase=2   ,    _lowerCamelCase=0.5   ,    **_lowerCamelCase   ,    ):
       super().__init__(**_lowerCamelCase   ,    pad_token_id=_lowerCamelCase   ,    bos_token_id=_lowerCamelCase   ,    eos_token_id=_lowerCamelCase       )
       a		:Any									=			hidden_size
       a		:str									=			feat_extract_norm
       a		:List[Any]									=			feat_extract_activation
       a		:Tuple									=			list(_lowerCamelCase       )
       a		:Any									=			list(_lowerCamelCase       )
       a		:List[Any]									=			list(_lowerCamelCase       )
       a		:Union[str, Any]									=			conv_bias
       a		:str									=			num_conv_pos_embeddings
       a		:str									=			num_conv_pos_embedding_groups
       a		:Tuple									=			len(self.conv_dim       )
       a		:int									=			num_hidden_layers
       a		:Any									=			intermediate_size
       a		:Optional[Any]									=			hidden_act
       a		:Tuple									=			num_attention_heads
       a		:Any									=			hidden_dropout
       a		:Any									=			attention_dropout
       a		:Optional[Any]									=			activation_dropout
       a		:Optional[Any]									=			feat_proj_dropout
       a		:Any									=			final_dropout
       a		:int									=			layerdrop
       a		:int									=			layer_norm_eps
       a		:Dict									=			initializer_range
       a		:Dict									=			num_ctc_classes
       a		:Optional[Any]									=			vocab_size
       a		:str									=			do_stable_layer_norm
       a		:Tuple									=			use_weighted_layer_sum
       a		:Any									=			classifier_proj_size

       if (
           (len(self.conv_stride       ) != self.num_feat_extract_layers)
           or (len(self.conv_kernel       ) != self.num_feat_extract_layers)
           or (len(self.conv_dim       ) != self.num_feat_extract_layers)
       ):
             raise ValueError(
                 '''Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='''
                 ''' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='''
                 F''' {len(self.conv_dim       )}`, `len(config.conv_stride) = {len(self.conv_stride       )}`,'''
                 F''' `len(config.conv_kernel) = {len(self.conv_kernel       )}`.'''       )

       # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
       a		:List[Any]									=			apply_spec_augment
       a		:Any									=			mask_time_prob
       a		:Union[str, Any]									=			mask_time_length
       a		:str									=			mask_time_min_masks
       a		:Tuple									=			mask_feature_prob
       a		:Dict									=			mask_feature_length
       a		:int									=			mask_feature_min_masks

       # parameters for pretraining with codevector quantized representations
       a		:Union[str, Any]									=			num_codevectors_per_group
       a		:Dict									=			num_codevector_groups
       a		:List[Any]									=			contrastive_logits_temperature
       a		:Union[str, Any]									=			feat_quantizer_dropout
       a		:Optional[Any]									=			num_negatives
       a		:Tuple									=			codevector_dim
       a		:Optional[Any]									=			proj_codevector_dim
       a		:Union[str, Any]									=			diversity_loss_weight

       # ctc loss
       a		:List[Any]									=			ctc_loss_reduction
       a		:Union[str, Any]									=			ctc_zero_infinity

       # pretraining loss
       a		:int									=			replace_prob




 @property
 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       return functools.reduce(operator.mul   ,    self.conv_stride   ,    1       )





