


import os
import unittest

from transformers import RealmTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.models.realm.tokenization_realm import RealmTokenizer
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english







@require_tokenizers
class      __lowercase  (__SCREAMING_SNAKE_CASE     ,    unittest.TestCase   ):





							"""simple docstring"""







							_UpperCAmelCase     =		RealmTokenizer
							_UpperCAmelCase     =		RealmTokenizerFast
							_UpperCAmelCase     =		True
							_UpperCAmelCase     =		True
							_UpperCAmelCase     =		filter_non_english






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										super().setUp()

										SCREAMING_SNAKE_CASE_						:			int       						= [
										    '[UNK]',
										    '[CLS]',
										    '[SEP]',
										    '[PAD]',
										    '[MASK]',
										    'want',
										    '##want',
										    '##ed',
										    'wa',
										    'un',
										    'runn',
										    '##ing',
										    ',',
										    'low',
										    'lowest',
										]
										SCREAMING_SNAKE_CASE_						:			Tuple       						= 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]    )    )






							def  UpperCamelCase__			(	self       ,		lowerCAmelCase__    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= 'UNwant\u00E9d,running'
										SCREAMING_SNAKE_CASE_						:			Any       						= 'unwanted, running'
										return input_text, output_text






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= self.tokenizer_class(self.vocab_file    )

										SCREAMING_SNAKE_CASE_						:			Tuple       						= tokenizer.tokenize('UNwant\u00E9d,running'    )
										self.assertListEqual(lowerCAmelCase__       ,		['un', '##want', '##ed', ',', 'runn', '##ing']    )
										self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__    )       ,		[9, 6, 7, 1_2, 1_0, 1_1]    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										if not self.test_rust_tokenizer:
													return

										SCREAMING_SNAKE_CASE_						:			List[Any]       						= self.get_tokenizer()
										SCREAMING_SNAKE_CASE_						:			Dict       						= self.get_rust_tokenizer()

										SCREAMING_SNAKE_CASE_						:			Any       						= 'UNwant\u00E9d,running'

										SCREAMING_SNAKE_CASE_						:			Any       						= tokenizer.tokenize(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			str       						= rust_tokenizer.tokenize(lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			Dict       						= tokenizer.encode(lowerCAmelCase__       ,		add_special_tokens=lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= rust_tokenizer.encode(lowerCAmelCase__       ,		add_special_tokens=lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= self.get_rust_tokenizer()
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= tokenizer.encode(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			str       						= rust_tokenizer.encode(lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )

										# With lower casing
										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= self.get_tokenizer(do_lower_case=lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			List[str]       						= self.get_rust_tokenizer(do_lower_case=lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			List[Any]       						= 'UNwant\u00E9d,running'

										SCREAMING_SNAKE_CASE_						:			str       						= tokenizer.tokenize(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= rust_tokenizer.tokenize(lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= tokenizer.encode(lowerCAmelCase__       ,		add_special_tokens=lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= rust_tokenizer.encode(lowerCAmelCase__       ,		add_special_tokens=lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			Any       						= self.get_rust_tokenizer()
										SCREAMING_SNAKE_CASE_						:			List[str]       						= tokenizer.encode(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Any       						= rust_tokenizer.encode(lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Dict       						= BasicTokenizer()

										self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'    )       ,		['ah', '\u535A', '\u63A8', 'zz']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= BasicTokenizer(do_lower_case=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '    )       ,		['hello', '!', 'how', 'are', 'you', '?']    )
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )       ,		['hello']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= BasicTokenizer(do_lower_case=lowerCAmelCase__       ,		strip_accents=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )       ,		['hällo', '!', 'how', 'are', 'you', '?']    )
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )       ,		['h\u00E9llo']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			List[Any]       						= BasicTokenizer(do_lower_case=lowerCAmelCase__       ,		strip_accents=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )       ,		['hallo', '!', 'how', 'are', 'you', '?']    )
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )       ,		['hello']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Tuple       						= BasicTokenizer(do_lower_case=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )       ,		['hallo', '!', 'how', 'are', 'you', '?']    )
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )       ,		['hello']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Any       						= BasicTokenizer(do_lower_case=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '    )       ,		['HeLLo', '!', 'how', 'Are', 'yoU', '?']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= BasicTokenizer(do_lower_case=lowerCAmelCase__       ,		strip_accents=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )       ,		['HäLLo', '!', 'how', 'Are', 'yoU', '?']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			List[Any]       						= BasicTokenizer(do_lower_case=lowerCAmelCase__       ,		strip_accents=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )       ,		['HaLLo', '!', 'how', 'Are', 'yoU', '?']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Any       						= BasicTokenizer(do_lower_case=lowerCAmelCase__       ,		never_split=['[UNK]']    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'    )       ,		['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= {}
										for i, token in enumerate(lowerCAmelCase__    ):
													SCREAMING_SNAKE_CASE_						:			Any       						= i
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= WordpieceTokenizer(vocab=lowerCAmelCase__       ,		unk_token='[UNK]'    )

										self.assertListEqual(tokenizer.tokenize(''    )       ,		[]    )

										self.assertListEqual(tokenizer.tokenize('unwanted running'    )       ,		['un', '##want', '##ed', 'runn', '##ing']    )

										self.assertListEqual(tokenizer.tokenize('unwantedX running'    )       ,		['[UNK]', 'runn', '##ing']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										self.assertTrue(_is_whitespace(' '    )    )
										self.assertTrue(_is_whitespace('\t'    )    )
										self.assertTrue(_is_whitespace('\r'    )    )
										self.assertTrue(_is_whitespace('\n'    )    )
										self.assertTrue(_is_whitespace('\u00A0'    )    )

										self.assertFalse(_is_whitespace('A'    )    )
										self.assertFalse(_is_whitespace('-'    )    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										self.assertTrue(_is_control('\u0005'    )    )

										self.assertFalse(_is_control('A'    )    )
										self.assertFalse(_is_control(' '    )    )
										self.assertFalse(_is_control('\t'    )    )
										self.assertFalse(_is_control('\r'    )    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										self.assertTrue(_is_punctuation('-'    )    )
										self.assertTrue(_is_punctuation('$'    )    )
										self.assertTrue(_is_punctuation('`'    )    )
										self.assertTrue(_is_punctuation('.'    )    )

										self.assertFalse(_is_punctuation('A'    )    )
										self.assertFalse(_is_punctuation(' '    )    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			List[Any]       						= self.get_tokenizer()

										# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
										self.assertListEqual([tokenizer.tokenize(lowerCAmelCase__    ) for t in ['Test', '\xad', 'test']]       ,		[['[UNK]'], [], ['[UNK]']]    )

										if self.test_rust_tokenizer:
													SCREAMING_SNAKE_CASE_						:			str       						= self.get_rust_tokenizer()
													self.assertListEqual(
													    [rust_tokenizer.tokenize(lowerCAmelCase__    ) for t in ['Test', '\xad', 'test']]       ,		[['[UNK]'], [], ['[UNK]']]    )






							@slow
							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			str       						= self.tokenizer_class.from_pretrained('bert-base-uncased'    )

										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= tokenizer.encode('sequence builders'       ,		add_special_tokens=lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= tokenizer.encode('multi-sequence build'       ,		add_special_tokens=lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Any       						= tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__       ,		lowerCAmelCase__    )

										assert encoded_sentence == [1_0_1] + text + [1_0_2]
										assert encoded_pair == [1_0_1] + text + [1_0_2] + text_a + [1_0_2]






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
													with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
																SCREAMING_SNAKE_CASE_						:			Optional[int]       						= self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__       ,		**lowerCAmelCase__    )

																SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
																SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= tokenizer_r.encode_plus(
																    lowerCAmelCase__       ,		return_attention_mask=lowerCAmelCase__       ,		return_token_type_ids=lowerCAmelCase__       ,		return_offsets_mapping=lowerCAmelCase__       ,		add_special_tokens=lowerCAmelCase__       ,		)

																SCREAMING_SNAKE_CASE_						:			List[Any]       						= tokenizer_r.do_lower_case if hasattr(lowerCAmelCase__       ,		'do_lower_case'    ) else False
																SCREAMING_SNAKE_CASE_						:			str       						= (
																    [
																        ((0, 0), tokenizer_r.cls_token),
																        ((0, 1), 'A'),
																        ((1, 2), ','),
																        ((3, 5), 'na'),
																        ((5, 6), '##ï'),
																        ((6, 8), '##ve'),
																        ((9, 1_5), tokenizer_r.mask_token),
																        ((1_6, 2_1), 'Allen'),
																        ((2_1, 2_3), '##NL'),
																        ((2_3, 2_4), '##P'),
																        ((2_5, 3_3), 'sentence'),
																        ((3_3, 3_4), '.'),
																        ((0, 0), tokenizer_r.sep_token),
																    ]
																    if not do_lower_case
																    else [
																        ((0, 0), tokenizer_r.cls_token),
																        ((0, 1), 'a'),
																        ((1, 2), ','),
																        ((3, 8), 'naive'),
																        ((9, 1_5), tokenizer_r.mask_token),
																        ((1_6, 2_1), 'allen'),
																        ((2_1, 2_3), '##nl'),
																        ((2_3, 2_4), '##p'),
																        ((2_5, 3_3), 'sentence'),
																        ((3_3, 3_4), '.'),
																        ((0, 0), tokenizer_r.sep_token),
																    ]
																)

																self.assertEqual(
																    [e[1] for e in expected_results]       ,		tokenizer_r.convert_ids_to_tokens(tokens['input_ids']    )    )
																self.assertEqual([e[0] for e in expected_results]       ,		tokens['offset_mapping']    )






							@slow
							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
													with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
																SCREAMING_SNAKE_CASE_						:			str       						= self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__       ,		**lowerCAmelCase__    )
																SCREAMING_SNAKE_CASE_						:			List[Any]       						= self.tokenizer_class.from_pretrained(lowerCAmelCase__       ,		**lowerCAmelCase__    )
																SCREAMING_SNAKE_CASE_						:			Optional[int]       						= [['Hello world!', 'Nice to meet you!'], ['The cute cat.', 'The adorable dog.']]

																SCREAMING_SNAKE_CASE_						:			List[Any]       						= tokenizer_r.batch_encode_candidates(lowerCAmelCase__       ,		max_length=1_0       ,		return_tensors='np'    )
																SCREAMING_SNAKE_CASE_						:			Any       						= tokenizer_p.batch_encode_candidates(lowerCAmelCase__       ,		max_length=1_0       ,		return_tensors='np'    )

																SCREAMING_SNAKE_CASE_						:			Optional[int]       						= (2, 2, 1_0)

																self.assertEqual(encoded_sentence_r['input_ids'].shape       ,		lowerCAmelCase__    )
																self.assertEqual(encoded_sentence_r['attention_mask'].shape       ,		lowerCAmelCase__    )
																self.assertEqual(encoded_sentence_r['token_type_ids'].shape       ,		lowerCAmelCase__    )

																self.assertEqual(encoded_sentence_p['input_ids'].shape       ,		lowerCAmelCase__    )
																self.assertEqual(encoded_sentence_p['attention_mask'].shape       ,		lowerCAmelCase__    )
																self.assertEqual(encoded_sentence_p['token_type_ids'].shape       ,		lowerCAmelCase__    )









import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType







@require_torch
class      __lowercase  :





							"""simple docstring"""







							_UpperCAmelCase     =		()
							_UpperCAmelCase     =		True






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= self.config_class

										# test default config
										SCREAMING_SNAKE_CASE_						:			Tuple       						= config_class()
										self.assertIsNotNone(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Dict       						= ['stem'] + [F'''stage{idx}''' for idx in range(1       ,		len(config.depths    ) + 1    )]
										self.assertEqual(config.stage_names       ,		lowerCAmelCase__    )
										self.assertTrue(set(config.out_features    ).issubset(set(config.stage_names    )    )    )

										# Test out_features and out_indices are correctly set
										# out_features and out_indices both None
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= config_class(out_features=lowerCAmelCase__       ,		out_indices=lowerCAmelCase__    )
										self.assertEqual(config.out_features       ,		[config.stage_names[-1]]    )
										self.assertEqual(config.out_indices       ,		[len(config.stage_names    ) - 1]    )

										# out_features and out_indices both set
										SCREAMING_SNAKE_CASE_						:			str       						= config_class(out_features=['stem', 'stage1']       ,		out_indices=[0, 1]    )
										self.assertEqual(config.out_features       ,		['stem', 'stage1']    )
										self.assertEqual(config.out_indices       ,		[0, 1]    )

										# Only out_features set
										SCREAMING_SNAKE_CASE_						:			List[str]       						= config_class(out_features=['stage1', 'stage3']    )
										self.assertEqual(config.out_features       ,		['stage1', 'stage3']    )
										self.assertEqual(config.out_indices       ,		[1, 3]    )

										# Only out_indices set
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= config_class(out_indices=[0, 2]    )
										self.assertEqual(config.out_features       ,		[config.stage_names[0], config.stage_names[2]]    )
										self.assertEqual(config.out_indices       ,		[0, 2]    )

										# Error raised when out_indices do not correspond to out_features
										with self.assertRaises(lowerCAmelCase__    ):
													SCREAMING_SNAKE_CASE_						:			str       						= config_class(out_features=['stage1', 'stage2']       ,		out_indices=[0, 2]    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			Tuple       						= self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= model_class(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			int       						= inspect.signature(model.forward    )
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													SCREAMING_SNAKE_CASE_						:			Any       						= [*signature.parameters.keys()]
													SCREAMING_SNAKE_CASE_						:			Optional[int]       						= ['pixel_values']
													self.assertListEqual(arg_names[:1]       ,		lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			str       						= self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Any       						= model_class(lowerCAmelCase__    )
													self.assertEqual(len(model.channels    )       ,		len(config.out_features    )    )
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= model.num_features
													SCREAMING_SNAKE_CASE_						:			Dict       						= [config.stage_names.index(lowerCAmelCase__    ) for feat in config.out_features]
													SCREAMING_SNAKE_CASE_						:			List[str]       						= [num_features[idx] for idx in out_indices]
													self.assertListEqual(model.channels       ,		lowerCAmelCase__    )

													SCREAMING_SNAKE_CASE_						:			Tuple       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Dict       						= None
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model_class(lowerCAmelCase__    )
													self.assertEqual(len(model.channels    )       ,		1    )
													self.assertListEqual(model.channels       ,		[num_features[-1]]    )

													SCREAMING_SNAKE_CASE_						:			Dict       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Tuple       						= None
													SCREAMING_SNAKE_CASE_						:			int       						= model_class(lowerCAmelCase__    )
													self.assertEqual(len(model.channels    )       ,		1    )
													self.assertListEqual(model.channels       ,		[num_features[-1]]    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model(**lowerCAmelCase__    )

													self.assertEqual(len(result.feature_maps    )       ,		len(config.out_features    )    )
													self.assertEqual(len(model.channels    )       ,		len(config.out_features    )    )
													self.assertEqual(len(result.feature_maps    )       ,		len(config.out_indices    )    )
													self.assertEqual(len(model.channels    )       ,		len(config.out_indices    )    )

													# Check output of last stage is taken if out_features=None, out_indices=None
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= None
													SCREAMING_SNAKE_CASE_						:			int       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			List[Any]       						= model(**lowerCAmelCase__    )

													self.assertEqual(len(result.feature_maps    )       ,		1    )
													self.assertEqual(len(model.channels    )       ,		1    )

													SCREAMING_SNAKE_CASE_						:			Tuple       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			int       						= None
													SCREAMING_SNAKE_CASE_						:			Dict       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			List[str]       						= model(**lowerCAmelCase__    )

													self.assertEqual(len(result.feature_maps    )       ,		1    )
													self.assertEqual(len(model.channels    )       ,		1    )

													# Check backbone can be initialized with fresh weights
													SCREAMING_SNAKE_CASE_						:			Tuple       						= copy.deepcopy(lowerCAmelCase__    )
													SCREAMING_SNAKE_CASE_						:			Dict       						= False
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()
													SCREAMING_SNAKE_CASE_						:			str       						= model(**lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= self.model_tester.prepare_config_and_inputs_for_common()

										for backbone_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			List[str]       						= backbone_class(lowerCAmelCase__    )

													self.assertTrue(hasattr(lowerCAmelCase__       ,		'backbone_type'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'stage_names'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'num_features'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'out_indices'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'out_features'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'out_feature_channels'    )    )
													self.assertTrue(hasattr(lowerCAmelCase__       ,		'channels'    )    )

													self.assertIsInstance(backbone.backbone_type       ,		lowerCAmelCase__    )
													# Verify num_features has been initialized in the backbone init
													self.assertIsNotNone(backbone.num_features    )
													self.assertTrue(len(backbone.channels    ) == len(backbone.out_indices    )    )
													self.assertTrue(len(backbone.stage_names    ) == len(backbone.num_features    )    )
													self.assertTrue(len(backbone.channels    ) <= len(backbone.num_features    )    )
													self.assertTrue(len(backbone.out_feature_channels    ) == len(backbone.stage_names    )    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			List[str]       						= self.model_tester.prepare_config_and_inputs_for_common()
										SCREAMING_SNAKE_CASE_						:			Tuple       						= inputs_dict['pixel_values'].shape[0]

										for backbone_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			Optional[int]       						= backbone_class(lowerCAmelCase__    )
													backbone.to(lowerCAmelCase__    )
													backbone.eval()

													SCREAMING_SNAKE_CASE_						:			Dict       						= backbone(**lowerCAmelCase__    )

													# Test default outputs and verify feature maps
													self.assertIsInstance(outputs.feature_maps       ,		lowerCAmelCase__    )
													self.assertTrue(len(outputs.feature_maps    ) == len(backbone.channels    )    )
													for feature_map, n_channels in zip(outputs.feature_maps       ,		backbone.channels    ):
																self.assertTrue(feature_map.shape[:2]       ,		(batch_size, n_channels)    )
													self.assertIsNone(outputs.hidden_states    )
													self.assertIsNone(outputs.attentions    )

													# Test output_hidden_states=True
													SCREAMING_SNAKE_CASE_						:			List[Any]       						= backbone(**lowerCAmelCase__       ,		output_hidden_states=lowerCAmelCase__    )
													self.assertIsNotNone(outputs.hidden_states    )
													self.assertTrue(len(outputs.hidden_states    )       ,		len(backbone.stage_names    )    )
													for hidden_state, n_channels in zip(outputs.hidden_states       ,		backbone.channels    ):
																self.assertTrue(hidden_state.shape[:2]       ,		(batch_size, n_channels)    )

													# Test output_attentions=True
													if self.has_attentions:
																SCREAMING_SNAKE_CASE_						:			Tuple       						= backbone(**lowerCAmelCase__       ,		output_attentions=lowerCAmelCase__    )
																self.assertIsNotNone(outputs.attentions    )





