



"""simple docstring"""







from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import TFResNetForImageClassification, TFResNetModel
							from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor
class        __A       :







		'''simple docstring'''





		def __init__(	self						:  str			,_snake_case						:  List[Any]			,_snake_case						:  Optional[int]=3			,_snake_case						:  Optional[int]=32			,_snake_case						:  Union[str, Any]=3			,_snake_case						:  int=10			,_snake_case						:  List[str]=[10, 20, 30, 40]			,_snake_case						:  Any=[1, 1, 2, 1]			,_snake_case						:  int=True			,_snake_case						:  Optional[Any]=True			,_snake_case						:  Union[str, Any]="relu"			,_snake_case						:  Dict=3			,_snake_case						:  Any=None			,)					->		str:






				"""simple docstring"""



				lowercase__   :    int				=			parent
				lowercase__   :    Optional[Any]				=			batch_size
				lowercase__   :    Optional[Any]				=			image_size
				lowercase__   :    Optional[Any]				=			num_channels
				lowercase__   :    Optional[Any]				=			embeddings_size
				lowercase__   :    Optional[Any]				=			hidden_sizes
				lowercase__   :    str				=			depths
				lowercase__   :    Tuple				=			is_training
				lowercase__   :    List[Any]				=			use_labels
				lowercase__   :    Union[str, Any]				=			hidden_act
				lowercase__   :    Union[str, Any]				=			num_labels
				lowercase__   :    Tuple				=			scope
				lowercase__   :    Optional[Any]				=			len(_snake_case						)







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






				"""simple docstring"""



				lowercase__   :    List[Any]				=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

				lowercase__   :    Tuple				=			None
				if self.use_labels:
						lowercase__   :    Dict				=			ids_tensor([self.batch_size]			,self.num_labels						)

				lowercase__   :    int				=			self.get_config()

				return config, pixel_values, labels







		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Optional[Any]:






				"""simple docstring"""



				return ResNetConfig(
				    num_channels=self.num_channels			,embeddings_size=self.embeddings_size			,hidden_sizes=self.hidden_sizes			,depths=self.depths			,hidden_act=self.hidden_act			,num_labels=self.num_labels			,image_size=self.image_size			,)







		def 					UpperCAmelCase    (	self						:  List[str]			,_snake_case						:  Optional[int]			,_snake_case						:  int			,_snake_case						:  Tuple						)					->		List[Any]:






				"""simple docstring"""



				lowercase__   :    Optional[int]				=			TFResNetModel(config=_snake_case						)
				lowercase__   :    List[str]				=			model(_snake_case						)
				# expected last hidden states: B, C, H // 32, W // 32
				self.parent.assertEqual(
				    result.last_hidden_state.shape			,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)			,)







		def 					UpperCAmelCase    (	self						:  Optional[int]			,_snake_case						:  Optional[Any]			,_snake_case						:  int			,_snake_case						:  Any						)					->		Tuple:






				"""simple docstring"""



				lowercase__   :    Tuple				=			self.num_labels
				lowercase__   :    Union[str, Any]				=			TFResNetForImageClassification(_snake_case						)
				lowercase__   :    List[str]				=			model(_snake_case			,labels=_snake_case						)
				self.parent.assertEqual(result.logits.shape			,(self.batch_size, self.num_labels)						)







		def 					UpperCAmelCase    (	self						:  Tuple						)					->		str:






				"""simple docstring"""



				lowercase__   :    Dict				=			self.prepare_config_and_inputs()
				lowercase__		,			lowercase__		,			lowercase__   :    Union[str, Any]				=			config_and_inputs
				lowercase__   :    Dict				=			{'''pixel_values''': pixel_values}
				return config, inputs_dict





@require_tf
class        __A       (	A_     ,A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Optional[int]   	=				(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
		lowerCAmelCase			:					Any   	=				(
		    {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
		    if is_tf_available()
		    else {}
		)

		lowerCAmelCase			:					List[Any]   	=				False
		lowerCAmelCase			:					List[Any]   	=				False
		lowerCAmelCase			:					int   	=				False
		lowerCAmelCase			:					Union[str, Any]   	=				False
		lowerCAmelCase			:					List[str]   	=				False







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






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			TFResNetModelTester(self						)
				lowercase__   :    int				=			ConfigTester(self			,config_class=_snake_case			,has_text_modality=_snake_case						)







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






				"""simple docstring"""



				self.create_and_test_config_common_properties()
				self.config_tester.create_and_test_config_to_json_string()
				self.config_tester.create_and_test_config_to_json_file()
				self.config_tester.create_and_test_config_from_and_save_pretrained()
				self.config_tester.create_and_test_config_with_num_labels()
				self.config_tester.check_config_can_be_init_without_params()
				self.config_tester.check_config_arguments_init()







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






				"""simple docstring"""



				return







		@unittest.skip(reason='''ResNet does not use inputs_embeds'''						)
		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		Dict:






				"""simple docstring"""



				pass







		@unittest.skip(reason='''ResNet does not support input and output embeddings'''						)
		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Optional[Any]:






				"""simple docstring"""



				pass







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






				"""simple docstring"""



				lowercase__		,			lowercase__   :    Dict				=			self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						lowercase__   :    str				=			model_class(_snake_case						)
						lowercase__   :    Dict				=			inspect.signature(model.call						)
						# signature.parameters is an OrderedDict => so arg_names order is deterministic
						lowercase__   :    Optional[int]				=			[*signature.parameters.keys()]

						lowercase__   :    Any				=			['''pixel_values''']
						self.assertListEqual(arg_names[:1]			,_snake_case						)







		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Optional[int]				=			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_snake_case						)







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






				"""simple docstring"""



				def check_hidden_states_output(_snake_case						:  Optional[int]			,_snake_case						:  List[str]			,_snake_case						:  Optional[Any]						):
						lowercase__   :    str				=			model_class(_snake_case						)
						lowercase__   :    Union[str, Any]				=			model(**self._prepare_for_class(_snake_case			,_snake_case						)						)

						lowercase__   :    List[Any]				=			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

						lowercase__   :    Tuple				=			self.model_tester.num_stages
						self.assertEqual(len(_snake_case						)			,expected_num_stages + 1						)

						# ResNet's feature maps are of shape (batch_size, num_channels, height, width)
						self.assertListEqual(
						    list(hidden_states[0].shape[-2:]						)			,[self.model_tester.image_size // 4, self.model_tester.image_size // 4]			,)

				lowercase__		,			lowercase__   :    int				=			self.model_tester.prepare_config_and_inputs_for_common()
				lowercase__   :    List[Any]				=			['''basic''', '''bottleneck''']
				for model_class in self.all_model_classes:
						for layer_type in layers_type:
								lowercase__   :    List[Any]				=			layer_type
								lowercase__   :    Dict				=			True
								check_hidden_states_output(_snake_case			,_snake_case			,_snake_case						)

								# check that output_hidden_states also work using config
								del inputs_dict["output_hidden_states"]
								lowercase__   :    Dict				=			True

								check_hidden_states_output(_snake_case			,_snake_case			,_snake_case						)







		def 					UpperCAmelCase    (	self						:  Dict						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*_snake_case						)







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






				"""simple docstring"""



				for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    Optional[Any]				=			TFResNetModel.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)





def      __UpperCAmelCase      (    )							->      Dict:
		lowercase__   :    List[str]				=			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
		return image





@require_tf
@require_vision
class        __A       (	unittest.TestCase    ):







		'''simple docstring'''





		@cached_property
		def 					UpperCAmelCase    (	self						:  str						)					->		Any:






				"""simple docstring"""



				return (
				    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)
				    if is_vision_available()
				    else None
				)







		@slow
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Dict:






				"""simple docstring"""



				lowercase__   :    Tuple				=			TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)

				lowercase__   :    Any				=			self.default_image_processor
				lowercase__   :    int				=			prepare_img()
				lowercase__   :    Tuple				=			image_processor(images=_snake_case			,return_tensors='''tf'''						)

				# forward pass
				lowercase__   :    Dict				=			model(**_snake_case						)

				# verify the logits
				lowercase__   :    List[str]				=			tf.TensorShape((1, 1_000)						)
				self.assertEqual(outputs.logits.shape			,_snake_case						)

				lowercase__   :    Any				=			tf.constant([-11.1069, -9.7877, -8.3777]						)

				self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()			,_snake_case			,atol=1e-4						)						)





"""simple docstring"""







import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


lowerCAmelCase_   						=   logging.get_logger(__name__)

lowerCAmelCase_   						=   '▁'

lowerCAmelCase_   						=   {'vocab_file': 'sentencepiece.bpe.model'}

lowerCAmelCase_   						=   {
    'vocab_file': {
        'facebook/xglm-564M': 'https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model',
    }
}

lowerCAmelCase_   						=   {
    'facebook/xglm-564M': 2_048,
}
class        __A       (	A_    ):







		'''simple docstring'''





		lowerCAmelCase			:					List[Any]   	=				VOCAB_FILES_NAMES
		lowerCAmelCase			:					Any   	=				PRETRAINED_VOCAB_FILES_MAP
		lowerCAmelCase			:					str   	=				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		lowerCAmelCase			:					int   	=				["input_ids", "attention_mask"]







		def __init__(	self						:  int			,_snake_case						:  Dict			,_snake_case						:  Dict="<s>"			,_snake_case						:  Dict="</s>"			,_snake_case						:  str="</s>"			,_snake_case						:  Optional[Any]="<s>"			,_snake_case						:  Optional[Any]="<unk>"			,_snake_case						:  Optional[int]="<pad>"			,_snake_case						:  Optional[Dict[str, Any]] = None			,**_snake_case						:  str			,)					->		None:






				"""simple docstring"""



				lowercase__   :    Any				=			{} if sp_model_kwargs is None else sp_model_kwargs

				# Compatibility with the original tokenizer
				lowercase__   :    Any				=			7
				lowercase__   :    Optional[int]				=			[f"""<madeupword{i}>""" for i in range(self.num_madeup_words						)]

				lowercase__   :    Dict				=			kwargs.get('''additional_special_tokens'''			,[]						)
				kwargs["additional_special_tokens"] += [
				    word for word in madeup_words if word not in kwargs["additional_special_tokens"]
				]

				super().__init__(
				    bos_token=_snake_case			,eos_token=_snake_case			,unk_token=_snake_case			,sep_token=_snake_case			,cls_token=_snake_case			,pad_token=_snake_case			,sp_model_kwargs=self.sp_model_kwargs			,**_snake_case			,)

				lowercase__   :    List[str]				=			spm.SentencePieceProcessor(**self.sp_model_kwargs						)
				self.sp_model.Load(str(_snake_case						)						)
				lowercase__   :    str				=			vocab_file

				# Original fairseq vocab and spm vocab must be "aligned":
				# Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
				# -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
				# fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
				# spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

				# The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
				lowercase__   :    Optional[int]				=			1

				# Mimic fairseq token-to-id alignment for the first 4 token
				lowercase__   :    Optional[int]				=			{'''<s>''': 0, '''<pad>''': 1, '''</s>''': 2, '''<unk>''': 3}

				lowercase__   :    List[str]				=			len(self.sp_model						)
				lowercase__   :    Tuple				=			{f"""<madeupword{i}>""": sp_size + i + self.fairseq_offset for i in range(self.num_madeup_words						)}
				self.fairseq_tokens_to_ids.update(_snake_case						)

				lowercase__   :    Union[str, Any]				=			{v: k for k, v in self.fairseq_tokens_to_ids.items()}







		def __getstate__(	self						:  int						)					->		Optional[int]:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			self.__dict__.copy()
				lowercase__   :    Optional[int]				=			None
				lowercase__   :    Any				=			self.sp_model.serialized_model_proto()
				return state







		def __setstate__(	self						:  Dict			,_snake_case						:  List[str]						)					->		Any:






				"""simple docstring"""



				lowercase__   :    int				=			d

				# for backward compatibility
				if not hasattr(self			,'''sp_model_kwargs'''						):
						lowercase__   :    Dict				=			{}

				lowercase__   :    Optional[int]				=			spm.SentencePieceProcessor(**self.sp_model_kwargs						)
				self.sp_model.LoadFromSerializedProto(self.sp_model_proto						)







		def 					UpperCAmelCase    (	self						:  Any			,_snake_case						:  List[int]			,_snake_case						:  Optional[List[int]] = None						)					->		List[int]:






				"""simple docstring"""



				if token_ids_a is None:
						return [self.sep_token_id] + token_ids_a
				lowercase__   :    Optional[Any]				=			[self.sep_token_id]
				return sep + token_ids_a + sep + sep + token_ids_a







		def 					UpperCAmelCase    (	self						:  Any			,_snake_case						:  List[int]			,_snake_case						:  Optional[List[int]] = None			,_snake_case						:  bool = False						)					->		List[int]:






				"""simple docstring"""



				if already_has_special_tokens:
						return super().get_special_tokens_mask(
						    token_ids_a=_snake_case			,token_ids_a=_snake_case			,already_has_special_tokens=_snake_case						)

				if token_ids_a is None:
						return [1] + ([0] * len(_snake_case						))
				return [1] + ([0] * len(_snake_case						)) + [1, 1] + ([0] * len(_snake_case						))







		def 					UpperCAmelCase    (	self						:  Union[str, Any]			,_snake_case						:  List[int]			,_snake_case						:  Optional[List[int]] = None						)					->		List[int]:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			[self.sep_token_id]

				if token_ids_a is None:
						return len(sep + token_ids_a						) * [0]
				return len(sep + token_ids_a + sep + sep + token_ids_a						) * [0]







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






				"""simple docstring"""



				return len(self.sp_model						) + self.fairseq_offset + self.num_madeup_words







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






				"""simple docstring"""



				lowercase__   :    Union[str, Any]				=			{self.convert_ids_to_tokens(_snake_case						): i for i in range(self.vocab_size						)}
				vocab.update(self.added_tokens_encoder						)
				return vocab







		def 					UpperCAmelCase    (	self						:  List[Any]			,_snake_case						:  str						)					->		List[str]:






				"""simple docstring"""



				return self.sp_model.encode(_snake_case			,out_type=_snake_case						)







		def 					UpperCAmelCase    (	self						:  int			,_snake_case						:  Optional[int]						)					->		List[Any]:






				"""simple docstring"""



				if token in self.fairseq_tokens_to_ids:
						return self.fairseq_tokens_to_ids[token]
				lowercase__   :    Tuple				=			self.sp_model.PieceToId(_snake_case						)

				# Need to return unknown token if the SP model returned 0
				return spm_id + self.fairseq_offset if spm_id else self.unk_token_id







		def 					UpperCAmelCase    (	self						:  Any			,_snake_case						:  List[str]						)					->		Any:






				"""simple docstring"""



				if index in self.fairseq_ids_to_tokens:
						return self.fairseq_ids_to_tokens[index]
				return self.sp_model.IdToPiece(index - self.fairseq_offset						)







		def 					UpperCAmelCase    (	self						:  Tuple			,_snake_case						:  Tuple						)					->		Union[str, Any]:






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			''''''.join(_snake_case						).replace(_snake_case			,''' '''						).strip()
				return out_string







		def 					UpperCAmelCase    (	self						:  Any			,_snake_case						:  str			,_snake_case						:  Optional[str] = None						)					->		Tuple[str]:






				"""simple docstring"""



				if not os.path.isdir(_snake_case						):
						logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""						)
						return
				lowercase__   :    Any				=			os.path.join(
				    _snake_case			,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']						)

				if os.path.abspath(self.vocab_file						) != os.path.abspath(_snake_case						) and os.path.isfile(self.vocab_file						):
						copyfile(self.vocab_file			,_snake_case						)
				elif not os.path.isfile(self.vocab_file						):
						with open(_snake_case			,'''wb'''						) as fi:
								lowercase__   :    Dict				=			self.sp_model.serialized_model_proto()
								fi.write(_snake_case						)

				return (out_vocab_file,)
