



import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch
							from torch import nn

							from transformers import (
							    MODEL_MAPPING,
							    BeitForImageClassification,
							    BeitForMaskedImageModeling,
							    BeitForSemanticSegmentation,
							    BeitModel,
							)
							from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							import PIL
							from PIL import Image

							from transformers import BeitImageProcessor


class   lowercase      :




							def __init__(  self				:   Optional[int]		,							_UpperCamelCase				:   List[str]		,							_UpperCamelCase				:   str=100		,							_UpperCamelCase				:   List[str]=13		,							_UpperCamelCase				:   Dict=30		,							_UpperCamelCase				:   Optional[Any]=2		,							_UpperCamelCase				:   int=3		,							_UpperCamelCase				:   List[str]=True		,							_UpperCamelCase				:   List[Any]=True		,							_UpperCamelCase				:   List[str]=32		,							_UpperCamelCase				:   Optional[Any]=4		,							_UpperCamelCase				:   List[str]=4		,							_UpperCamelCase				:   Optional[Any]=37		,							_UpperCamelCase				:   int="gelu"		,							_UpperCamelCase				:   Dict=0.1		,							_UpperCamelCase				:   Optional[Any]=0.1		,							_UpperCamelCase				:   Any=10		,							_UpperCamelCase				:   Dict=0.0_2		,							_UpperCamelCase				:   str=3		,							_UpperCamelCase				:   Optional[Any]=None		,							_UpperCamelCase				:   Tuple=[0, 1, 2, 3]		,							)   ->			Tuple:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    parent
												SCREAMING_SNAKE_CASE           =    100
												SCREAMING_SNAKE_CASE           =    batch_size
												SCREAMING_SNAKE_CASE           =    image_size
												SCREAMING_SNAKE_CASE           =    patch_size
												SCREAMING_SNAKE_CASE           =    num_channels
												SCREAMING_SNAKE_CASE           =    is_training
												SCREAMING_SNAKE_CASE           =    use_labels
												SCREAMING_SNAKE_CASE           =    hidden_size
												SCREAMING_SNAKE_CASE           =    num_hidden_layers
												SCREAMING_SNAKE_CASE           =    num_attention_heads
												SCREAMING_SNAKE_CASE           =    intermediate_size
												SCREAMING_SNAKE_CASE           =    hidden_act
												SCREAMING_SNAKE_CASE           =    hidden_dropout_prob
												SCREAMING_SNAKE_CASE           =    attention_probs_dropout_prob
												SCREAMING_SNAKE_CASE           =    type_sequence_label_size
												SCREAMING_SNAKE_CASE           =    initializer_range
												SCREAMING_SNAKE_CASE           =    scope
												SCREAMING_SNAKE_CASE           =    out_indices
												SCREAMING_SNAKE_CASE           =    num_labels

												# in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
												SCREAMING_SNAKE_CASE           =    (image_size // patch_size) ** 2
												SCREAMING_SNAKE_CASE           =    num_patches + 1




							def 		__snake_case(  self				:   Optional[Any] )   ->			List[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

												SCREAMING_SNAKE_CASE           =    None
												SCREAMING_SNAKE_CASE           =    None
												if self.use_labels:
																	SCREAMING_SNAKE_CASE           =    ids_tensor([self.batch_size]		,							self.type_sequence_label_size )
																	SCREAMING_SNAKE_CASE           =    ids_tensor([self.batch_size, self.image_size, self.image_size]		,							self.num_labels )

												SCREAMING_SNAKE_CASE           =    self.get_config()

												return config, pixel_values, labels, pixel_labels




							def 		__snake_case(  self				:   List[Any] )   ->			Dict:



												'''simple docstring'''

												return BeitConfig(
												    vocab_size=self.vocab_size		,							image_size=self.image_size		,							patch_size=self.patch_size		,							num_channels=self.num_channels		,							hidden_size=self.hidden_size		,							num_hidden_layers=self.num_hidden_layers		,							num_attention_heads=self.num_attention_heads		,							intermediate_size=self.intermediate_size		,							hidden_act=self.hidden_act		,							hidden_dropout_prob=self.hidden_dropout_prob		,							attention_probs_dropout_prob=self.attention_probs_dropout_prob		,							is_decoder=_a		,							initializer_range=self.initializer_range		,							out_indices=self.out_indices		,							)




							def 		__snake_case(  self				:   Union[str, Any]		,							_UpperCamelCase				:   Optional[int]		,							_UpperCamelCase				:   List[Any]		,							_UpperCamelCase				:   Optional[Any]		,							_UpperCamelCase				:   List[str] )   ->			Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    BeitModel(config=_a )
												model.to(_a )
												model.eval()
												SCREAMING_SNAKE_CASE           =    model(_a )
												self.parent.assertEqual(result.last_hidden_state.shape		,							(self.batch_size, self.seq_length, self.hidden_size) )




							def 		__snake_case(  self				:   List[Any]		,							_UpperCamelCase				:   int		,							_UpperCamelCase				:   Optional[int]		,							_UpperCamelCase				:   int		,							_UpperCamelCase				:   List[Any] )   ->			str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    BeitForMaskedImageModeling(config=_a )
												model.to(_a )
												model.eval()
												SCREAMING_SNAKE_CASE           =    model(_a )
												self.parent.assertEqual(result.logits.shape		,							(self.batch_size, self.seq_length - 1, self.vocab_size) )




							def 		__snake_case(  self				:   Tuple		,							_UpperCamelCase				:   List[Any]		,							_UpperCamelCase				:   Union[str, Any]		,							_UpperCamelCase				:   List[Any]		,							_UpperCamelCase				:   str )   ->			str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.type_sequence_label_size
												SCREAMING_SNAKE_CASE           =    BeitForImageClassification(_a )
												model.to(_a )
												model.eval()
												SCREAMING_SNAKE_CASE           =    model(_a		,							labels=_a )
												self.parent.assertEqual(result.logits.shape		,							(self.batch_size, self.type_sequence_label_size) )

												# test greyscale images
												SCREAMING_SNAKE_CASE           =    1
												SCREAMING_SNAKE_CASE           =    BeitForImageClassification(_a )
												model.to(_a )
												model.eval()

												SCREAMING_SNAKE_CASE           =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
												SCREAMING_SNAKE_CASE           =    model(_a		,							labels=_a )
												self.parent.assertEqual(result.logits.shape		,							(self.batch_size, self.type_sequence_label_size) )




							def 		__snake_case(  self				:   List[str]		,							_UpperCamelCase				:   List[Any]		,							_UpperCamelCase				:   List[Any]		,							_UpperCamelCase				:   Dict		,							_UpperCamelCase				:   Any )   ->			Optional[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.num_labels
												SCREAMING_SNAKE_CASE           =    BeitForSemanticSegmentation(_a )
												model.to(_a )
												model.eval()
												SCREAMING_SNAKE_CASE           =    model(_a )
												self.parent.assertEqual(
												    result.logits.shape		,							(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2) )
												SCREAMING_SNAKE_CASE           =    model(_a		,							labels=_a )
												self.parent.assertEqual(
												    result.logits.shape		,							(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2) )





							def 		__snake_case(  self				:   Optional[Any] )   ->			Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.prepare_config_and_inputs()
												SCREAMING_SNAKE_CASE           =    config_and_inputs
												SCREAMING_SNAKE_CASE           =    {"pixel_values": pixel_values}
												return config, inputs_dict



@require_torch
class   lowercase      (       a			,    a			,    unittest.TestCase       ):
							lowercase__  :    Optional[Any]									=							(
							    (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
							    if is_torch_available()
							    else ()
							)
							lowercase__  :    Optional[Any]									=							(
							    {
							        """feature-extraction""": BeitModel,
							        """image-classification""": BeitForImageClassification,
							        """image-segmentation""": BeitForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							lowercase__  :    str									=							False
							lowercase__  :    Union[str, Any]									=							False
							lowercase__  :    Dict									=							False




							def 		__snake_case(  self				:   Optional[Any] )   ->			Optional[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    BeitModelTester(self )
												SCREAMING_SNAKE_CASE           =    ConfigTester(self		,							config_class=_a		,							has_text_modality=_a		,							hidden_size=37 )




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



												'''simple docstring'''

												self.config_tester.run_common_tests()




							@unittest.skip(reason="BEiT does not use inputs_embeds" )
							def 		__snake_case(  self				:   List[Any] )   ->			Optional[Any]:



												'''simple docstring'''

												pass




							@require_torch_multi_gpu
							@unittest.skip(reason="BEiT has some layers using `add_module` which doesn't work well with `nn.DataParallel`" )
							def 		__snake_case(  self				:   Any )   ->			Tuple:



												'''simple docstring'''

												pass




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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																	SCREAMING_SNAKE_CASE           =    model_class(_a )
																	self.assertIsInstance(model.get_input_embeddings()		,							(nn.Module) )
																	SCREAMING_SNAKE_CASE           =    model.get_output_embeddings()
																	self.assertTrue(x is None or isinstance(_a		,							nn.Linear ) )




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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																	SCREAMING_SNAKE_CASE           =    model_class(_a )
																	SCREAMING_SNAKE_CASE           =    inspect.signature(model.forward )
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	SCREAMING_SNAKE_CASE           =    [*signature.parameters.keys()]

																	SCREAMING_SNAKE_CASE           =    ["pixel_values"]
																	self.assertListEqual(arg_names[:1]		,							_a )




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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_a )




							def 		__snake_case(  self				:   Optional[int] )   ->			Dict:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*_a )




							def 		__snake_case(  self				:   List[Any] )   ->			Optional[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*_a )




							def 		__snake_case(  self				:   str )   ->			Optional[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_semantic_segmentation(*_a )




							def 		__snake_case(  self				:   Dict )   ->			Optional[Any]:



												'''simple docstring'''

												if not self.model_tester.is_training:
																	return

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs_for_common()
												SCREAMING_SNAKE_CASE           =    True

												for model_class in self.all_model_classes:
																	# we don't test BeitForMaskedImageModeling
																	if model_class in [*get_values(_a ), BeitForMaskedImageModeling]:
																						continue

																	SCREAMING_SNAKE_CASE           =    model_class(_a )
																	model.to(_a )
																	model.train()
																	SCREAMING_SNAKE_CASE           =    self._prepare_for_class(_a		,							_a		,							return_labels=_a )
																	SCREAMING_SNAKE_CASE           =    model(**_a ).loss
																	loss.backward()




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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs_for_common()
												if not self.model_tester.is_training:
																	return

												SCREAMING_SNAKE_CASE           =    False
												SCREAMING_SNAKE_CASE           =    True

												for model_class in self.all_model_classes:
																	# we don't test BeitForMaskedImageModeling
																	if (
																	    model_class in [*get_values(_a ), BeitForMaskedImageModeling]
																	    or not model_class.supports_gradient_checkpointing
																	):
																						continue

																	SCREAMING_SNAKE_CASE           =    model_class(_a )
																	model.gradient_checkpointing_enable()
																	model.to(_a )
																	model.train()
																	SCREAMING_SNAKE_CASE           =    self._prepare_for_class(_a		,							_a		,							return_labels=_a )
																	SCREAMING_SNAKE_CASE           =    model(**_a ).loss
																	loss.backward()




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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs_for_common()

												SCREAMING_SNAKE_CASE           =    _config_zero_init(_a )
												for model_class in self.all_model_classes:
																	SCREAMING_SNAKE_CASE           =    model_class(config=_a )
																	for name, param in model.named_parameters():
																						# we skip lambda parameters as these require special initial values
																						# determined by config.layer_scale_init_value
																						if "lambda" in name:
																											continue
																						if param.requires_grad:
																											self.assertIn(
																											    ((param.data.mean() * 1e9).round() / 1e9).item()		,							[0.0, 1.0]		,							msg=F"Parameter {name} of model {model_class} seems not properly initialized"		,							)





							@slow
							def 		__snake_case(  self				:   str )   ->			Any:



												'''simple docstring'''

												for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	SCREAMING_SNAKE_CASE           =    BeitModel.from_pretrained(_a )
																	self.assertIsNotNone(_a )





def 		__lowerCamelCase							():
					SCREAMING_SNAKE_CASE           =    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
					return image


@require_torch
@require_vision
class   lowercase      (       unittest.TestCase       ):




							@cached_property
							def 		__snake_case(  self				:   Union[str, Any] )   ->			List[Any]:



												'''simple docstring'''

												return BeitImageProcessor.from_pretrained("microsoft/beit-base-patch16-224" ) if is_vision_available() else None




							@slow
							def 		__snake_case(  self				:   Optional[int] )   ->			int:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    BeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k" ).to(_a )

												SCREAMING_SNAKE_CASE           =    self.default_image_processor
												SCREAMING_SNAKE_CASE           =    prepare_img()
												SCREAMING_SNAKE_CASE           =    image_processor(images=_a		,							return_tensors="pt" ).pixel_values.to(_a )

												# prepare bool_masked_pos
												SCREAMING_SNAKE_CASE           =    torch.ones((1, 196)		,							dtype=torch.bool ).to(_a )

												# forward pass
												with torch.no_grad():
																	SCREAMING_SNAKE_CASE           =    model(pixel_values=_a		,							bool_masked_pos=_a )
												SCREAMING_SNAKE_CASE           =    outputs.logits

												# verify the logits
												SCREAMING_SNAKE_CASE           =    torch.Size((1, 196, 8_192) )
												self.assertEqual(logits.shape		,							_a )

												SCREAMING_SNAKE_CASE           =    torch.tensor(
												    [[-3.2_4_3_7, 0.5_0_7_2, -1_3.9_1_7_4], [-3.2_4_5_6, 0.4_9_4_8, -1_3.9_4_0_1], [-3.2_0_3_3, 0.5_1_2_1, -1_3.8_5_5_0]] ).to(_a )

												self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]		,							_a		,							atol=1e-2 ) )




							@slow
							def 		__snake_case(  self				:   Dict )   ->			Dict:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    BeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224" ).to(_a )

												SCREAMING_SNAKE_CASE           =    self.default_image_processor
												SCREAMING_SNAKE_CASE           =    prepare_img()
												SCREAMING_SNAKE_CASE           =    image_processor(images=_a		,							return_tensors="pt" ).to(_a )

												# forward pass
												with torch.no_grad():
																	SCREAMING_SNAKE_CASE           =    model(**_a )
												SCREAMING_SNAKE_CASE           =    outputs.logits

												# verify the logits
												SCREAMING_SNAKE_CASE           =    torch.Size((1, 1_000) )
												self.assertEqual(logits.shape		,							_a )

												SCREAMING_SNAKE_CASE           =    torch.tensor([-1.2_3_8_5, -1.0_9_8_7, -1.0_1_0_8] ).to(_a )

												self.assertTrue(torch.allclose(logits[0, :3]		,							_a		,							atol=1e-4 ) )

												SCREAMING_SNAKE_CASE           =    281
												self.assertEqual(logits.argmax(-1 ).item()		,							_a )




							@slow
							def 		__snake_case(  self				:   int )   ->			Dict:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    BeitForImageClassification.from_pretrained("microsoft/beit-large-patch16-224-pt22k-ft22k" ).to(
												    _a )

												SCREAMING_SNAKE_CASE           =    self.default_image_processor
												SCREAMING_SNAKE_CASE           =    prepare_img()
												SCREAMING_SNAKE_CASE           =    image_processor(images=_a		,							return_tensors="pt" ).to(_a )

												# forward pass
												with torch.no_grad():
																	SCREAMING_SNAKE_CASE           =    model(**_a )
												SCREAMING_SNAKE_CASE           =    outputs.logits

												# verify the logits
												SCREAMING_SNAKE_CASE           =    torch.Size((1, 21_841) )
												self.assertEqual(logits.shape		,							_a )

												SCREAMING_SNAKE_CASE           =    torch.tensor([1.6_8_8_1, -0.2_7_8_7, 0.5_9_0_1] ).to(_a )

												self.assertTrue(torch.allclose(logits[0, :3]		,							_a		,							atol=1e-4 ) )

												SCREAMING_SNAKE_CASE           =    2_396
												self.assertEqual(logits.argmax(-1 ).item()		,							_a )




							@slow
							def 		__snake_case(  self				:   Union[str, Any] )   ->			int:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640" )
												SCREAMING_SNAKE_CASE           =    model.to(_a )

												SCREAMING_SNAKE_CASE           =    BeitImageProcessor(do_resize=_a		,							size=640		,							do_center_crop=_a )

												SCREAMING_SNAKE_CASE           =    load_dataset("hf-internal-testing/fixtures_ade20k"		,							split="test" )
												SCREAMING_SNAKE_CASE           =    Image.open(ds[0]["file"] )
												SCREAMING_SNAKE_CASE           =    image_processor(images=_a		,							return_tensors="pt" ).to(_a )

												# forward pass
												with torch.no_grad():
																	SCREAMING_SNAKE_CASE           =    model(**_a )
												SCREAMING_SNAKE_CASE           =    outputs.logits

												# verify the logits
												SCREAMING_SNAKE_CASE           =    torch.Size((1, 150, 160, 160) )
												self.assertEqual(logits.shape		,							_a )

												SCREAMING_SNAKE_CASE           =    version.parse(PIL.__version__ ) < version.parse("9.0.0" )

												if is_pillow_less_than_a:
																	SCREAMING_SNAKE_CASE           =    torch.tensor(
																	    [
																	        [[-4.9_2_2_5, -2.3_9_5_4, -3.0_5_2_2], [-2.8_8_2_2, -1.0_0_4_6, -1.7_5_6_1], [-2.9_5_4_9, -1.3_2_2_8, -2.1_3_4_7]],
																	        [[-5.8_1_6_8, -3.4_1_2_9, -4.0_7_7_8], [-3.8_6_5_1, -2.2_2_1_4, -3.0_2_7_7], [-3.8_3_5_6, -2.4_6_4_3, -3.3_5_3_5]],
																	        [[-0.0_0_7_8, 3.9_9_5_2, 4.0_7_5_4], [2.9_8_5_6, 4.6_9_4_4, 5.0_0_3_5], [3.2_4_1_3, 4.7_8_1_3, 4.9_9_6_9]],
																	    ]		,							device=_a		,							)
												else:
																	SCREAMING_SNAKE_CASE           =    torch.tensor(
																	    [
																	        [[-4.8_9_6_0, -2.3_6_8_8, -3.0_3_5_5], [-2.8_4_7_8, -0.9_8_3_6, -1.7_4_1_8], [-2.9_4_4_9, -1.3_3_3_2, -2.1_4_5_6]],
																	        [[-5.8_0_8_1, -3.4_1_2_4, -4.1_0_0_6], [-3.8_5_6_1, -2.2_0_8_1, -3.0_3_2_3], [-3.8_3_6_5, -2.4_6_0_1, -3.3_6_6_9]],
																	        [[-0.0_3_0_9, 3.9_8_6_8, 4.0_5_4_0], [2.9_6_4_0, 4.6_8_7_7, 4.9_9_7_6], [3.2_0_8_1, 4.7_6_9_0, 4.9_9_4_2]],
																	    ]		,							device=_a		,							)

												self.assertTrue(torch.allclose(logits[0, :3, :3, :3]		,							_a		,							atol=1e-4 ) )





							@slow
							def 		__snake_case(  self				:   str )   ->			Any:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640" )
												SCREAMING_SNAKE_CASE           =    model.to(_a )

												SCREAMING_SNAKE_CASE           =    BeitImageProcessor(do_resize=_a		,							size=640		,							do_center_crop=_a )

												SCREAMING_SNAKE_CASE           =    load_dataset("hf-internal-testing/fixtures_ade20k"		,							split="test" )
												SCREAMING_SNAKE_CASE           =    Image.open(ds[0]["file"] )
												SCREAMING_SNAKE_CASE           =    image_processor(images=_a		,							return_tensors="pt" ).to(_a )

												# forward pass
												with torch.no_grad():
																	SCREAMING_SNAKE_CASE           =    model(**_a )

												SCREAMING_SNAKE_CASE           =    outputs.logits.detach().cpu()

												SCREAMING_SNAKE_CASE           =    image_processor.post_process_semantic_segmentation(outputs=_a		,							target_sizes=[(500, 300)] )
												SCREAMING_SNAKE_CASE           =    torch.Size((500, 300) )
												self.assertEqual(segmentation[0].shape		,							_a )

												SCREAMING_SNAKE_CASE           =    image_processor.post_process_semantic_segmentation(outputs=_a )
												SCREAMING_SNAKE_CASE           =    torch.Size((160, 160) )
												self.assertEqual(segmentation[0].shape		,							_a )





import functools
import operator

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


_lowerCamelCase   :				int     			=						logging.get_logger(__name__)

_lowerCamelCase   :				Union[str, Any]     			=						{
    '''microsoft/unispeech-sat-base-100h-libri-ft''': (
        '''https://huggingface.co/microsoft/unispeech-sat-base-100h-libri-ft/resolve/main/config.json'''
    ),
    # See all UniSpeechSat models at https://huggingface.co/models?filter=unispeech_sat
}


class   lowercase      (       a       ):
							lowercase__  :    Tuple									=							"""unispeech-sat"""




							def __init__(  self				:   str		,							_UpperCamelCase				:   Tuple=32		,							_UpperCamelCase				:   Union[str, Any]=768		,							_UpperCamelCase				:   Tuple=12		,							_UpperCamelCase				:   List[str]=12		,							_UpperCamelCase				:   Tuple=3_072		,							_UpperCamelCase				:   List[str]="gelu"		,							_UpperCamelCase				:   Tuple=0.1		,							_UpperCamelCase				:   Any=0.1		,							_UpperCamelCase				:   Union[str, Any]=0.1		,							_UpperCamelCase				:   Dict=0.0		,							_UpperCamelCase				:   Tuple=0.0		,							_UpperCamelCase				:   Tuple=0.1		,							_UpperCamelCase				:   Optional[Any]=0.1		,							_UpperCamelCase				:   Tuple=0.0_2		,							_UpperCamelCase				:   Optional[int]=1e-5		,							_UpperCamelCase				:   Union[str, Any]="group"		,							_UpperCamelCase				:   Optional[int]="gelu"		,							_UpperCamelCase				:   Tuple=(512, 512, 512, 512, 512, 512, 512)		,							_UpperCamelCase				:   List[str]=(5, 2, 2, 2, 2, 2, 2)		,							_UpperCamelCase				:   Optional[int]=(10, 3, 3, 3, 3, 2, 2)		,							_UpperCamelCase				:   Optional[int]=False		,							_UpperCamelCase				:   Dict=128		,							_UpperCamelCase				:   Optional[int]=16		,							_UpperCamelCase				:   Tuple=False		,							_UpperCamelCase				:   Union[str, Any]=True		,							_UpperCamelCase				:   Optional[Any]=0.0_5		,							_UpperCamelCase				:   Union[str, Any]=10		,							_UpperCamelCase				:   Union[str, Any]=2		,							_UpperCamelCase				:   str=0.0		,							_UpperCamelCase				:   List[Any]=10		,							_UpperCamelCase				:   Optional[int]=0		,							_UpperCamelCase				:   Any=320		,							_UpperCamelCase				:   List[Any]=2		,							_UpperCamelCase				:   str=0.1		,							_UpperCamelCase				:   str=100		,							_UpperCamelCase				:   int=256		,							_UpperCamelCase				:   Optional[Any]=256		,							_UpperCamelCase				:   List[Any]=0.1		,							_UpperCamelCase				:   str="mean"		,							_UpperCamelCase				:   int=False		,							_UpperCamelCase				:   Optional[Any]=False		,							_UpperCamelCase				:   Any=256		,							_UpperCamelCase				:   str=(512, 512, 512, 512, 1_500)		,							_UpperCamelCase				:   List[Any]=(5, 3, 3, 1, 1)		,							_UpperCamelCase				:   Union[str, Any]=(1, 2, 3, 1, 1)		,							_UpperCamelCase				:   Any=512		,							_UpperCamelCase				:   str=0		,							_UpperCamelCase				:   int=1		,							_UpperCamelCase				:   Any=2		,							_UpperCamelCase				:   Optional[Any]=504		,							**_UpperCamelCase				:   str		,							)   ->			int:



												'''simple docstring'''

												super().__init__(**_UpperCamelCase		,							pad_token_id=_UpperCamelCase		,							bos_token_id=_UpperCamelCase		,							eos_token_id=_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    hidden_size
												SCREAMING_SNAKE_CASE           =    feat_extract_norm
												SCREAMING_SNAKE_CASE           =    feat_extract_activation
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    conv_bias
												SCREAMING_SNAKE_CASE           =    num_conv_pos_embeddings
												SCREAMING_SNAKE_CASE           =    num_conv_pos_embedding_groups
												SCREAMING_SNAKE_CASE           =    len(self.conv_dim )
												SCREAMING_SNAKE_CASE           =    num_hidden_layers
												SCREAMING_SNAKE_CASE           =    intermediate_size
												SCREAMING_SNAKE_CASE           =    hidden_act
												SCREAMING_SNAKE_CASE           =    num_attention_heads
												SCREAMING_SNAKE_CASE           =    hidden_dropout
												SCREAMING_SNAKE_CASE           =    attention_dropout
												SCREAMING_SNAKE_CASE           =    activation_dropout
												SCREAMING_SNAKE_CASE           =    feat_proj_dropout
												SCREAMING_SNAKE_CASE           =    final_dropout
												SCREAMING_SNAKE_CASE           =    layerdrop
												SCREAMING_SNAKE_CASE           =    layer_norm_eps
												SCREAMING_SNAKE_CASE           =    initializer_range
												SCREAMING_SNAKE_CASE           =    vocab_size
												SCREAMING_SNAKE_CASE           =    num_clusters
												SCREAMING_SNAKE_CASE           =    do_stable_layer_norm
												SCREAMING_SNAKE_CASE           =    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
												SCREAMING_SNAKE_CASE           =    apply_spec_augment
												SCREAMING_SNAKE_CASE           =    mask_time_prob
												SCREAMING_SNAKE_CASE           =    mask_time_length
												SCREAMING_SNAKE_CASE           =    mask_time_min_masks
												SCREAMING_SNAKE_CASE           =    mask_feature_prob
												SCREAMING_SNAKE_CASE           =    mask_feature_length
												SCREAMING_SNAKE_CASE           =    mask_feature_min_masks

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

												# ctc loss
												SCREAMING_SNAKE_CASE           =    ctc_loss_reduction
												SCREAMING_SNAKE_CASE           =    ctc_zero_infinity

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

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





							@property
							def 		__snake_case(  self				:   Tuple )   ->			str:



												'''simple docstring'''

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




