




'''simple docstring'''


import functools
import operator

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


_snake_case				:				Tuple       							=		logging.get_logger(__name__)

_snake_case				:				List[str]       							=		{
    'facebook/wav2vec2-base-960h': 'https://huggingface.co/facebook/wav2vec2-base-960h/resolve/main/config.json',
    # See all Wav2Vec2 models at https://huggingface.co/models?filter=wav2vec2
}

class       A   (		_a   ):
							lowercase_          =    'wav2vec2'







							def __init__(  self	:  str							,      lowerCAmelCase_	:  List[str]=32							,      lowerCAmelCase_	:  str=7_68							,      lowerCAmelCase_	:  Tuple=12							,      lowerCAmelCase_	:  Any=12							,      lowerCAmelCase_	:  Union[str, Any]=30_72							,      lowerCAmelCase_	:  Optional[int]="gelu"							,      lowerCAmelCase_	:  List[str]=0.1							,      lowerCAmelCase_	:  Dict=0.1							,      lowerCAmelCase_	:  int=0.1							,      lowerCAmelCase_	:  List[str]=0.0							,      lowerCAmelCase_	:  List[str]=0.0							,      lowerCAmelCase_	:  Optional[int]=0.1							,      lowerCAmelCase_	:  List[str]=0.1							,      lowerCAmelCase_	:  Optional[int]=0.0_2							,      lowerCAmelCase_	:  Optional[Any]=1e-5							,      lowerCAmelCase_	:  Dict="group"							,      lowerCAmelCase_	:  Optional[int]="gelu"							,      lowerCAmelCase_	:  int=(5_12, 5_12, 5_12, 5_12, 5_12, 5_12, 5_12)							,      lowerCAmelCase_	:  Optional[int]=(5, 2, 2, 2, 2, 2, 2)							,      lowerCAmelCase_	:  Optional[Any]=(10, 3, 3, 3, 3, 2, 2)							,      lowerCAmelCase_	:  List[Any]=False							,      lowerCAmelCase_	:  List[Any]=1_28							,      lowerCAmelCase_	:  Any=16							,      lowerCAmelCase_	:  Any=False							,      lowerCAmelCase_	:  Union[str, Any]=True							,      lowerCAmelCase_	:  Optional[Any]=0.0_5							,      lowerCAmelCase_	:  Tuple=10							,      lowerCAmelCase_	:  int=2							,      lowerCAmelCase_	:  Optional[int]=0.0							,      lowerCAmelCase_	:  Union[str, Any]=10							,      lowerCAmelCase_	:  Union[str, Any]=0							,      lowerCAmelCase_	:  int=3_20							,      lowerCAmelCase_	:  List[str]=2							,      lowerCAmelCase_	:  Union[str, Any]=0.1							,      lowerCAmelCase_	:  List[str]=1_00							,      lowerCAmelCase_	:  Tuple=2_56							,      lowerCAmelCase_	:  Dict=2_56							,      lowerCAmelCase_	:  Dict=0.1							,      lowerCAmelCase_	:  Any="sum"							,      lowerCAmelCase_	:  Union[str, Any]=False							,      lowerCAmelCase_	:  int=False							,      lowerCAmelCase_	:  List[Any]=2_56							,      lowerCAmelCase_	:  List[str]=(5_12, 5_12, 5_12, 5_12, 15_00)							,      lowerCAmelCase_	:  Optional[Any]=(5, 3, 3, 1, 1)							,      lowerCAmelCase_	:  Union[str, Any]=(1, 2, 3, 1, 1)							,      lowerCAmelCase_	:  Dict=5_12							,      lowerCAmelCase_	:  Dict=0							,      lowerCAmelCase_	:  Union[str, Any]=1							,      lowerCAmelCase_	:  Optional[int]=2							,      lowerCAmelCase_	:  Optional[Any]=False							,      lowerCAmelCase_	:  Dict=3							,      lowerCAmelCase_	:  List[str]=2							,      lowerCAmelCase_	:  int=3							,      lowerCAmelCase_	:  Optional[Any]=None							,      lowerCAmelCase_	:  List[str]=None							,      **lowerCAmelCase_	:  str							,      )      ->							int:


														"""simple docstring"""


														super().__init__(**lowerCAmelCase_							,      pad_token_id=lowerCAmelCase_							,      bos_token_id=lowerCAmelCase_							,      eos_token_id=lowerCAmelCase_ )
														_a     					=    hidden_size
														_a     					=    feat_extract_norm
														_a     					=    feat_extract_activation
														_a     					=    list(lowerCAmelCase_ )
														_a     					=    list(lowerCAmelCase_ )
														_a     					=    list(lowerCAmelCase_ )
														_a     					=    conv_bias
														_a     					=    num_conv_pos_embeddings
														_a     					=    num_conv_pos_embedding_groups
														_a     					=    len(self.conv_dim )
														_a     					=    num_hidden_layers
														_a     					=    intermediate_size
														_a     					=    hidden_act
														_a     					=    num_attention_heads
														_a     					=    hidden_dropout
														_a     					=    attention_dropout
														_a     					=    activation_dropout
														_a     					=    feat_proj_dropout
														_a     					=    final_dropout
														_a     					=    layerdrop
														_a     					=    layer_norm_eps
														_a     					=    initializer_range
														_a     					=    vocab_size
														_a     					=    do_stable_layer_norm
														_a     					=    use_weighted_layer_sum

														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     					=    apply_spec_augment
														_a     					=    mask_time_prob
														_a     					=    mask_time_length
														_a     					=    mask_time_min_masks
														_a     					=    mask_feature_prob
														_a     					=    mask_feature_length
														_a     					=    mask_feature_min_masks

														# parameters for pretraining with codevector quantized representations
														_a     					=    num_codevectors_per_group
														_a     					=    num_codevector_groups
														_a     					=    contrastive_logits_temperature
														_a     					=    feat_quantizer_dropout
														_a     					=    num_negatives
														_a     					=    codevector_dim
														_a     					=    proj_codevector_dim
														_a     					=    diversity_loss_weight

														# ctc loss
														_a     					=    ctc_loss_reduction
														_a     					=    ctc_zero_infinity

														# adapter
														_a     					=    add_adapter
														_a     					=    adapter_kernel_size
														_a     					=    adapter_stride
														_a     					=    num_adapter_layers
														_a     					=    output_hidden_size or hidden_size
														_a     					=    adapter_attn_dim

														# SequenceClassification-specific parameter. Feel free to ignore for other classes.
														_a     					=    classifier_proj_size

														# XVector-specific parameters. Feel free to ignore for other classes.
														_a     					=    list(lowerCAmelCase_ )
														_a     					=    list(lowerCAmelCase_ )
														_a     					=    list(lowerCAmelCase_ )
														_a     					=    xvector_output_dim







							@property
							def        __lowerCAmelCase      (  self	:  List[Any] )      ->							int:


														"""simple docstring"""


														return functools.reduce(operator.mul							,      self.conv_stride							,      1 )







'''simple docstring'''


import unittest

from transformers import TrOCRConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers.models.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM

@require_torch
class       A   :







							def __init__(  self	:  Union[str, Any]							,      lowerCAmelCase_	:  List[Any]							,      lowerCAmelCase_	:  Union[str, Any]=99							,      lowerCAmelCase_	:  Optional[int]=13							,      lowerCAmelCase_	:  Tuple=16							,      lowerCAmelCase_	:  Optional[int]=7							,      lowerCAmelCase_	:  Optional[Any]=True							,      lowerCAmelCase_	:  Union[str, Any]=True							,      lowerCAmelCase_	:  Any=True							,      lowerCAmelCase_	:  Union[str, Any]=False							,      lowerCAmelCase_	:  int=True							,      lowerCAmelCase_	:  Tuple=2							,      lowerCAmelCase_	:  Any=32							,      lowerCAmelCase_	:  str=4							,      lowerCAmelCase_	:  Optional[Any]=4							,      lowerCAmelCase_	:  Optional[Any]=30							,      lowerCAmelCase_	:  int=0							,      lowerCAmelCase_	:  Any=1							,      lowerCAmelCase_	:  str=2							,      lowerCAmelCase_	:  Union[str, Any]=None							,      )      ->							Any:


														"""simple docstring"""


														_a     					=    parent
														_a     					=    batch_size
														_a     					=    decoder_seq_length
														# For common tests
														_a     					=    self.decoder_seq_length
														_a     					=    is_training
														_a     					=    use_attention_mask
														_a     					=    use_labels

														_a     					=    vocab_size
														_a     					=    d_model
														_a     					=    d_model
														_a     					=    decoder_layers
														_a     					=    decoder_layers
														_a     					=    decoder_ffn_dim
														_a     					=    decoder_attention_heads
														_a     					=    decoder_attention_heads
														_a     					=    eos_token_id
														_a     					=    bos_token_id
														_a     					=    pad_token_id
														_a     					=    decoder_start_token_id
														_a     					=    use_cache
														_a     					=    max_position_embeddings

														_a     					=    None
														_a     					=    decoder_seq_length
														_a     					=    2
														_a     					=    1







							def        __lowerCAmelCase      (  self	:  str )      ->							str:


														"""simple docstring"""


														_a     					=    ids_tensor([self.batch_size, self.decoder_seq_length]							,      self.vocab_size )

														_a     					=    None
														if self.use_attention_mask:
																					_a     					=    ids_tensor([self.batch_size, self.decoder_seq_length]							,      vocab_size=2 )

														_a     					=    None
														if self.use_labels:
																					_a     					=    ids_tensor([self.batch_size, self.decoder_seq_length]							,      self.vocab_size )

														_a     					=    TrOCRConfig(
														    vocab_size=self.vocab_size							,      d_model=self.d_model							,      decoder_layers=self.decoder_layers							,      decoder_ffn_dim=self.decoder_ffn_dim							,      decoder_attention_heads=self.decoder_attention_heads							,      eos_token_id=self.eos_token_id							,      bos_token_id=self.bos_token_id							,      use_cache=self.use_cache							,      pad_token_id=self.pad_token_id							,      decoder_start_token_id=self.decoder_start_token_id							,      max_position_embeddings=self.max_position_embeddings							,      )

														return (config, input_ids, attention_mask, lm_labels)







							def        __lowerCAmelCase      (  self	:  List[str]							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  Optional[Any]							,      lowerCAmelCase_	:  int							,      )      ->							int:


														"""simple docstring"""


														_a     					=    True
														_a     					=    TrOCRDecoder(config=lowerCAmelCase_ ).to(lowerCAmelCase_ ).eval()
														_a     					=    input_ids[:2]

														input_ids[input_ids == 0] += 1
														# first forward pass
														_a     					=    model(lowerCAmelCase_							,      use_cache=lowerCAmelCase_ )
														_a     					=    model(lowerCAmelCase_ )
														_a     					=    model(lowerCAmelCase_							,      use_cache=lowerCAmelCase_ )

														self.parent.assertTrue(len(lowerCAmelCase_ ) == len(lowerCAmelCase_ ) )
														self.parent.assertTrue(len(lowerCAmelCase_ ) == len(lowerCAmelCase_ ) + 1 )

														_a     					=    outputs['''past_key_values''']

														# create hypothetical next token and extent to next_input_ids
														_a     					=    ids_tensor((2, 1)							,      config.vocab_size - 1 ) + 1

														# append to next input_ids and
														_a     					=    torch.cat([input_ids, next_tokens]							,      dim=-1 )

														_a     					=    model(lowerCAmelCase_ )['''last_hidden_state''']
														_a     					=    model(lowerCAmelCase_							,      past_key_values=lowerCAmelCase_ )['''last_hidden_state''']

														# select random slice
														_a     					=    ids_tensor((1,)							,      output_from_past.shape[-1] ).item()
														_a     					=    output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
														_a     					=    output_from_past[:, 0, random_slice_idx].detach()

														# test that outputs are equal for slice
														assert torch.allclose(lowerCAmelCase_							,      lowerCAmelCase_							,      atol=1e-3 )







							def        __lowerCAmelCase      (  self	:  int )      ->							List[str]:


														"""simple docstring"""


														_a     					=    self.prepare_config_and_inputs()
														_a					,							_a					,							_a					,							_a     					=    config_and_inputs

														_a     					=    {'''input_ids''': input_ids, '''attention_mask''': attention_mask}
														return config, inputs_dict



@require_torch
class       A   (		_a					,_a					,_a					,unittest.TestCase   ):
							lowercase_          =    (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
							lowercase_          =    (TrOCRForCausalLM,) if is_torch_available() else ()
							lowercase_          =    {'text-generation': TrOCRForCausalLM} if is_torch_available() else {}
							lowercase_          =    True
							lowercase_          =    False







							def        __lowerCAmelCase      (  self	:  List[str] )      ->							str:


														"""simple docstring"""


														_a     					=    TrOCRStandaloneDecoderModelTester(self							,      is_training=lowerCAmelCase_ )
														_a     					=    ConfigTester(self							,      config_class=lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  List[str] )      ->							Any:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Dict:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Optional[int]:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							Optional[int]:


														"""simple docstring"""


														self.config_tester.run_common_tests()







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Optional[int]:


														"""simple docstring"""


														_a     					=    self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_decoder_model_past(*lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							str:


														"""simple docstring"""


														return







							@unittest.skip('''The model doesn\'t support left padding''' )  # and it's not used enough to be worth fixing :)
							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							Optional[int]:


														"""simple docstring"""


														pass

