


import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
						from test_module.custom_tokenization_fast import CustomTokenizerFast



class 							A   (	unittest.TestCase							):
					'''simple docstring'''






					def   lowerCamelCase__					(self   :						List[str]		)						->       Dict:




							"""simple docstring"""


							lowercase__					      =		0

					@slow
					def   lowerCamelCase__					(self   :						Dict		)						->       List[Any]:




							"""simple docstring"""


							for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
									lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase		)
									self.assertIsNotNone(_lowercase		)
									self.assertIsInstance(_lowercase				, (BertTokenizer, BertTokenizerFast)		)
									self.assertGreater(len(_lowercase		)				, 0		)

							for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
									lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase		)
									self.assertIsNotNone(_lowercase		)
									self.assertIsInstance(_lowercase				, (GPTaTokenizer, GPTaTokenizerFast)		)
									self.assertGreater(len(_lowercase		)				, 0		)

					def   lowerCamelCase__					(self   :						Any		)						->       Dict:




							"""simple docstring"""


							lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase		)
							self.assertIsInstance(_lowercase				, (BertTokenizer, BertTokenizerFast)		)
							self.assertEqual(tokenizer.vocab_size				, 12		)

					def   lowerCamelCase__					(self   :						Dict		)						->       str:




							"""simple docstring"""


							lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase		)
							self.assertIsInstance(_lowercase				, (RobertaTokenizer, RobertaTokenizerFast)		)
							self.assertEqual(tokenizer.vocab_size				, 20		)

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




							"""simple docstring"""


							lowercase__					      =		AutoConfig.from_pretrained(_lowercase		)
							self.assertIsInstance(_lowercase				, _lowercase		)
							# Check that tokenizer_type ≠ model_type
							lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase				, config=_lowercase		)
							self.assertIsInstance(_lowercase				, (BertTokenizer, BertTokenizerFast)		)
							self.assertEqual(tokenizer.vocab_size				, 12		)

					def   lowerCamelCase__					(self   :						str		)						->       str:




							"""simple docstring"""


							with tempfile.TemporaryDirectory() as tmp_dir:
									shutil.copy("""./tests/fixtures/vocab.txt"""				, os.path.join(_lowercase				, """vocab.txt"""		)		)

									lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase				, tokenizer_type="""bert"""				, use_fast=_lowercase		)
									self.assertIsInstance(_lowercase				, _lowercase		)

							with tempfile.TemporaryDirectory() as tmp_dir:
									shutil.copy("""./tests/fixtures/vocab.json"""				, os.path.join(_lowercase				, """vocab.json"""		)		)
									shutil.copy("""./tests/fixtures/merges.txt"""				, os.path.join(_lowercase				, """merges.txt"""		)		)

									lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase				, tokenizer_type="""gpt2"""				, use_fast=_lowercase		)
									self.assertIsInstance(_lowercase				, _lowercase		)

					@require_tokenizers
					def   lowerCamelCase__					(self   :						str		)						->       Union[str, Any]:




							"""simple docstring"""


							with tempfile.TemporaryDirectory() as tmp_dir:
									shutil.copy("""./tests/fixtures/vocab.txt"""				, os.path.join(_lowercase				, """vocab.txt"""		)		)

									lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase				, tokenizer_type="""bert"""		)
									self.assertIsInstance(_lowercase				, _lowercase		)

							with tempfile.TemporaryDirectory() as tmp_dir:
									shutil.copy("""./tests/fixtures/vocab.json"""				, os.path.join(_lowercase				, """vocab.json"""		)		)
									shutil.copy("""./tests/fixtures/merges.txt"""				, os.path.join(_lowercase				, """merges.txt"""		)		)

									lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase				, tokenizer_type="""gpt2"""		)
									self.assertIsInstance(_lowercase				, _lowercase		)

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




							"""simple docstring"""


							with pytest.raises(_lowercase		):
									AutoTokenizer.from_pretrained("""./"""				, tokenizer_type="""xxx"""		)

					@require_tokenizers
					def   lowerCamelCase__					(self   :						List[str]		)						->       Union[str, Any]:




							"""simple docstring"""


							for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
									lowercase__					      =		tokenizer_class.from_pretrained("""wietsedv/bert-base-dutch-cased"""		)
									self.assertIsInstance(_lowercase				, (BertTokenizer, BertTokenizerFast)		)

									if isinstance(_lowercase				, _lowercase		):
											self.assertEqual(tokenizer.basic_tokenizer.do_lower_case				, _lowercase		)
									else:
											self.assertEqual(tokenizer.do_lower_case				, _lowercase		)

									self.assertEqual(tokenizer.model_max_length				, 512		)

					@require_tokenizers
					def   lowerCamelCase__					(self   :						Dict		)						->       List[str]:




							"""simple docstring"""


							for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
									with self.assertRaisesRegex(
									    _lowercase				, """julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier"""				, ):
											lowercase__					      =		tokenizer_class.from_pretrained("""julien-c/herlolip-not-exists"""		)

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




							"""simple docstring"""


							lowercase__					      =		TOKENIZER_MAPPING.values()
							lowercase__					      =		[]

							for slow_tok, fast_tok in tokenizers:
									if slow_tok is not None:
											tokenizer_names.append(slow_tok.__name__		)

									if fast_tok is not None:
											tokenizer_names.append(fast_tok.__name__		)

							for tokenizer_name in tokenizer_names:
									# must find the right class
									tokenizer_class_from_name(_lowercase		)

					@require_tokenizers
					def   lowerCamelCase__					(self   :						List[Any]		)						->       Any:




							"""simple docstring"""


							self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""				, use_fast=_lowercase		)				, _lowercase		)
							self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""		)				, _lowercase		)

					@require_tokenizers
					def   lowerCamelCase__					(self   :						Union[str, Any]		)						->       Union[str, Any]:




							"""simple docstring"""


							lowercase__					      =		AutoTokenizer.from_pretrained("""distilbert-base-uncased"""				, do_lower_case=_lowercase		)
							lowercase__					      =		"""Hello, world. How are you?"""
							lowercase__					      =		tokenizer.tokenize(_lowercase		)
							self.assertEqual("""[UNK]"""				, tokens[0]		)

							lowercase__					      =		AutoTokenizer.from_pretrained("""microsoft/mpnet-base"""				, do_lower_case=_lowercase		)
							lowercase__					      =		tokenizer.tokenize(_lowercase		)
							self.assertEqual("""[UNK]"""				, tokens[0]		)

					@require_tokenizers
					def   lowerCamelCase__					(self   :						Union[str, Any]		)						->       Optional[Any]:




							"""simple docstring"""


							lowercase__					      =		AutoTokenizer.from_pretrained("""robot-test/dummy-tokenizer-fast-with-model-config"""		)
							self.assertEqual(type(_lowercase		)				, _lowercase		)
							self.assertEqual(tokenizer.model_max_length				, 512		)
							self.assertEqual(tokenizer.vocab_size				, 3_0000		)
							self.assertEqual(tokenizer.unk_token				, """[UNK]"""		)
							self.assertEqual(tokenizer.padding_side				, """right"""		)
							self.assertEqual(tokenizer.truncation_side				, """right"""		)

					def   lowerCamelCase__					(self   :						str		)						->       str:




							"""simple docstring"""


							lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase		)
							self.assertIsInstance(_lowercase				, (BertTokenizer, BertTokenizerFast)		)
							with tempfile.TemporaryDirectory() as tmp_dir:
									tokenizer.save_pretrained(_lowercase		)
									lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase		)

							self.assertIsInstance(_lowercase				, tokenizer.__class__		)
							self.assertEqual(tokenizera.vocab_size				, 12		)

					def   lowerCamelCase__					(self   :						Union[str, Any]		)						->       List[str]:




							"""simple docstring"""


							lowercase__					      =		AutoTokenizer.from_pretrained("""ctrl"""		)
							# There is no fast CTRL so this always gives us a slow tokenizer.
							self.assertIsInstance(_lowercase				, _lowercase		)

					def   lowerCamelCase__					(self   :						Tuple		)						->       Tuple:




							"""simple docstring"""


							lowercase__					      =		get_tokenizer_config("""bert-base-cased"""		)
							lowercase__					      =		config.pop("""_commit_hash"""				, _lowercase		)
							# If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
							self.assertEqual(_lowercase				, {"""do_lower_case""": False}		)

							# This model does not have a tokenizer_config so we get back an empty dict.
							lowercase__					      =		get_tokenizer_config(_lowercase		)
							self.assertDictEqual(_lowercase				, {}		)

							# A tokenizer saved with `save_pretrained` always creates a tokenizer config.
							lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase		)
							with tempfile.TemporaryDirectory() as tmp_dir:
									tokenizer.save_pretrained(_lowercase		)
									lowercase__					      =		get_tokenizer_config(_lowercase		)

							# Check the class of the tokenizer was properly saved (note that it always saves the slow class).
							self.assertEqual(config["""tokenizer_class"""]				, """BertTokenizer"""		)

					def   lowerCamelCase__					(self   :						Any		)						->       int:




							"""simple docstring"""


							try:
									AutoConfig.register("""custom"""				, _lowercase		)

									AutoTokenizer.register(_lowercase				, slow_tokenizer_class=_lowercase		)
									# Trying to register something existing in the Transformers library will raise an error
									with self.assertRaises(_lowercase		):
											AutoTokenizer.register(_lowercase				, slow_tokenizer_class=_lowercase		)

									lowercase__					      =		CustomTokenizer.from_pretrained(_lowercase		)
									with tempfile.TemporaryDirectory() as tmp_dir:
											tokenizer.save_pretrained(_lowercase		)

											lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase		)
											self.assertIsInstance(_lowercase				, _lowercase		)

							finally:
									if "custom" in CONFIG_MAPPING._extra_content:
											del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in TOKENIZER_MAPPING._extra_content:
											del TOKENIZER_MAPPING._extra_content[CustomConfig]

					@require_tokenizers
					def   lowerCamelCase__					(self   :						Optional[Any]		)						->       Tuple:




							"""simple docstring"""


							try:
									AutoConfig.register("""custom"""				, _lowercase		)

									# Can register in two steps
									AutoTokenizer.register(_lowercase				, slow_tokenizer_class=_lowercase		)
									self.assertEqual(TOKENIZER_MAPPING[CustomConfig]				, (CustomTokenizer, None)		)
									AutoTokenizer.register(_lowercase				, fast_tokenizer_class=_lowercase		)
									self.assertEqual(TOKENIZER_MAPPING[CustomConfig]				, (CustomTokenizer, CustomTokenizerFast)		)

									del TOKENIZER_MAPPING._extra_content[CustomConfig]
									# Can register in one step
									AutoTokenizer.register(
									    _lowercase				, slow_tokenizer_class=_lowercase				, fast_tokenizer_class=_lowercase		)
									self.assertEqual(TOKENIZER_MAPPING[CustomConfig]				, (CustomTokenizer, CustomTokenizerFast)		)

									# Trying to register something existing in the Transformers library will raise an error
									with self.assertRaises(_lowercase		):
											AutoTokenizer.register(_lowercase				, fast_tokenizer_class=_lowercase		)

									# We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
									# and that model does not have a tokenizer.json
									with tempfile.TemporaryDirectory() as tmp_dir:
											lowercase__					      =		BertTokenizerFast.from_pretrained(_lowercase		)
											bert_tokenizer.save_pretrained(_lowercase		)
											lowercase__					      =		CustomTokenizerFast.from_pretrained(_lowercase		)

									with tempfile.TemporaryDirectory() as tmp_dir:
											tokenizer.save_pretrained(_lowercase		)

											lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase		)
											self.assertIsInstance(_lowercase				, _lowercase		)

											lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase				, use_fast=_lowercase		)
											self.assertIsInstance(_lowercase				, _lowercase		)

							finally:
									if "custom" in CONFIG_MAPPING._extra_content:
											del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in TOKENIZER_MAPPING._extra_content:
											del TOKENIZER_MAPPING._extra_content[CustomConfig]

					def   lowerCamelCase__					(self   :						List[str]		)						->       Union[str, Any]:




							"""simple docstring"""


							with self.assertRaises(_lowercase		):
									lowercase__					      =		AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""		)
							# If remote code is disabled, we can't load this config.
							with self.assertRaises(_lowercase		):
									lowercase__					      =		AutoTokenizer.from_pretrained(
									    """hf-internal-testing/test_dynamic_tokenizer"""				, trust_remote_code=_lowercase		)

							lowercase__					      =		AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""				, trust_remote_code=_lowercase		)
							self.assertTrue(tokenizer.special_attribute_present		)
							# Test tokenizer can be reloaded.
							with tempfile.TemporaryDirectory() as tmp_dir:
									tokenizer.save_pretrained(_lowercase		)
									lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase				, trust_remote_code=_lowercase		)
							self.assertTrue(reloaded_tokenizer.special_attribute_present		)

							if is_tokenizers_available():
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizerFast"""		)
									self.assertEqual(reloaded_tokenizer.__class__.__name__				, """NewTokenizerFast"""		)

									# Test we can also load the slow version
									lowercase__					      =		AutoTokenizer.from_pretrained(
									    """hf-internal-testing/test_dynamic_tokenizer"""				, trust_remote_code=_lowercase				, use_fast=_lowercase		)
									self.assertTrue(tokenizer.special_attribute_present		)
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizer"""		)
									# Test tokenizer can be reloaded.
									with tempfile.TemporaryDirectory() as tmp_dir:
											tokenizer.save_pretrained(_lowercase		)
											lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase				, trust_remote_code=_lowercase				, use_fast=_lowercase		)
									self.assertEqual(reloaded_tokenizer.__class__.__name__				, """NewTokenizer"""		)
									self.assertTrue(reloaded_tokenizer.special_attribute_present		)
							else:
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizer"""		)
									self.assertEqual(reloaded_tokenizer.__class__.__name__				, """NewTokenizer"""		)

					@require_tokenizers
					def   lowerCamelCase__					(self   :						List[Any]		)						->       List[Any]:




							"""simple docstring"""


							class 							A   (	UpperCAmelCase__							):
												'''simple docstring'''






												A__      =			False






							class 							A   (	UpperCAmelCase__							):
												'''simple docstring'''






												A__      =			NewTokenizer
												A__      =			False

							try:
									AutoConfig.register("""custom"""				, _lowercase		)
									AutoTokenizer.register(_lowercase				, slow_tokenizer_class=_lowercase		)
									AutoTokenizer.register(_lowercase				, fast_tokenizer_class=_lowercase		)
									# If remote code is not set, the default is to use local
									lowercase__					      =		AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""		)
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizerFast"""		)
									self.assertFalse(tokenizer.special_attribute_present		)
									lowercase__					      =		AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""				, use_fast=_lowercase		)
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizer"""		)
									self.assertFalse(tokenizer.special_attribute_present		)

									# If remote code is disabled, we load the local one.
									lowercase__					      =		AutoTokenizer.from_pretrained(
									    """hf-internal-testing/test_dynamic_tokenizer"""				, trust_remote_code=_lowercase		)
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizerFast"""		)
									self.assertFalse(tokenizer.special_attribute_present		)
									lowercase__					      =		AutoTokenizer.from_pretrained(
									    """hf-internal-testing/test_dynamic_tokenizer"""				, trust_remote_code=_lowercase				, use_fast=_lowercase		)
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizer"""		)
									self.assertFalse(tokenizer.special_attribute_present		)

									# If remote is enabled, we load from the Hub
									lowercase__					      =		AutoTokenizer.from_pretrained(
									    """hf-internal-testing/test_dynamic_tokenizer"""				, trust_remote_code=_lowercase		)
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizerFast"""		)
									self.assertTrue(tokenizer.special_attribute_present		)
									lowercase__					      =		AutoTokenizer.from_pretrained(
									    """hf-internal-testing/test_dynamic_tokenizer"""				, trust_remote_code=_lowercase				, use_fast=_lowercase		)
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizer"""		)
									self.assertTrue(tokenizer.special_attribute_present		)

							finally:
									if "custom" in CONFIG_MAPPING._extra_content:
											del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in TOKENIZER_MAPPING._extra_content:
											del TOKENIZER_MAPPING._extra_content[CustomConfig]

					def   lowerCamelCase__					(self   :						Dict		)						->       int:




							"""simple docstring"""


							lowercase__					      =		AutoTokenizer.from_pretrained(
							    """hf-internal-testing/test_dynamic_tokenizer_legacy"""				, trust_remote_code=_lowercase		)
							self.assertTrue(tokenizer.special_attribute_present		)
							if is_tokenizers_available():
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizerFast"""		)

									# Test we can also load the slow version
									lowercase__					      =		AutoTokenizer.from_pretrained(
									    """hf-internal-testing/test_dynamic_tokenizer_legacy"""				, trust_remote_code=_lowercase				, use_fast=_lowercase		)
									self.assertTrue(tokenizer.special_attribute_present		)
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizer"""		)
							else:
									self.assertEqual(tokenizer.__class__.__name__				, """NewTokenizer"""		)

					def   lowerCamelCase__					(self   :						Any		)						->       int:




							"""simple docstring"""


							with self.assertRaisesRegex(
							    _lowercase				, """bert-base is not a local folder and is not a valid model identifier"""		):
									lowercase__					      =		AutoTokenizer.from_pretrained("""bert-base"""		)

					def   lowerCamelCase__					(self   :						Dict		)						->       Tuple:




							"""simple docstring"""


							with self.assertRaisesRegex(
							    _lowercase				, r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""		):
									lowercase__					      =		AutoTokenizer.from_pretrained(_lowercase				, revision="""aaaaaa"""		)


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




							"""simple docstring"""


							lowercase__					      =		AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""		)
							with RequestCounter() as counter:
									lowercase__					      =		AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""		)
									self.assertEqual(counter.get_request_count				, 0		)
									self.assertEqual(counter.head_request_count				, 1		)
									self.assertEqual(counter.other_request_count				, 0		)





import warnings
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


A	:		List[str]    =       logging.get_logger(__name__)

A	:		List[Any]    =       {
    'nvidia/segformer-b0-finetuned-ade-512-512': (
        'https://huggingface.co/nvidia/segformer-b0-finetuned-ade-512-512/resolve/main/config.json'
    ),
    # See all SegFormer models at https://huggingface.co/models?filter=segformer
}



class 							A   (	UpperCAmelCase__							):
					'''simple docstring'''






					A__      =			'''segformer'''

					def __init__(self   :						Dict				, _UpperCAmelCase   :						Optional[int]=3				, _UpperCAmelCase   :						Dict=4				, _UpperCAmelCase   :						Union[str, Any]=[2, 2, 2, 2]				, _UpperCAmelCase   :						List[str]=[8, 4, 2, 1]				, _UpperCAmelCase   :						str=[32, 64, 160, 256]				, _UpperCAmelCase   :						Optional[int]=[7, 3, 3, 3]				, _UpperCAmelCase   :						int=[4, 2, 2, 2]				, _UpperCAmelCase   :						str=[1, 2, 5, 8]				, _UpperCAmelCase   :						Optional[int]=[4, 4, 4, 4]				, _UpperCAmelCase   :						List[Any]="gelu"				, _UpperCAmelCase   :						Optional[Any]=0.0				, _UpperCAmelCase   :						Dict=0.0				, _UpperCAmelCase   :						Dict=0.1				, _UpperCAmelCase   :						List[str]=0.02				, _UpperCAmelCase   :						str=0.1				, _UpperCAmelCase   :						Optional[Any]=1E-6				, _UpperCAmelCase   :						Optional[Any]=256				, _UpperCAmelCase   :						Any=255				, **_UpperCAmelCase   :						str				, )						->       Tuple:




							"""simple docstring"""


							super().__init__(**_UpperCAmelCase		)

							if "reshape_last_stage" in kwargs and kwargs["reshape_last_stage"] is False:
									warnings.warn(
									    """Reshape_last_stage is set to False in this config. This argument is deprecated and will soon be"""
									    """ removed, as the behaviour will default to that of reshape_last_stage = True."""				, _UpperCAmelCase				, )

							lowercase__					      =		num_channels
							lowercase__					      =		num_encoder_blocks
							lowercase__					      =		depths
							lowercase__					      =		sr_ratios
							lowercase__					      =		hidden_sizes
							lowercase__					      =		patch_sizes
							lowercase__					      =		strides
							lowercase__					      =		mlp_ratios
							lowercase__					      =		num_attention_heads
							lowercase__					      =		hidden_act
							lowercase__					      =		hidden_dropout_prob
							lowercase__					      =		attention_probs_dropout_prob
							lowercase__					      =		classifier_dropout_prob
							lowercase__					      =		initializer_range
							lowercase__					      =		drop_path_rate
							lowercase__					      =		layer_norm_eps
							lowercase__					      =		decoder_hidden_size
							lowercase__					      =		kwargs.get("""reshape_last_stage"""				, _UpperCAmelCase		)
							lowercase__					      =		semantic_loss_ignore_index






class 							A   (	UpperCAmelCase__							):
					'''simple docstring'''






					A__      =			version.parse('''1.11'''							)

					@property
					def   lowerCamelCase__					(self   :						Optional[int]		)						->       Mapping[str, Mapping[int, str]]:




							"""simple docstring"""


							return OrderedDict(
							    [
							        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
							    ]		)

					@property
					def   lowerCamelCase__					(self   :						Optional[int]		)						->       float:




							"""simple docstring"""


							return 1E-4


					@property
					def   lowerCamelCase__					(self   :						Optional[Any]		)						->       int:




							"""simple docstring"""


							return 12

