



import json
import os
import shutil
import tempfile
from unittest import TestCase

from transformers import BartTokenizer, BartTokenizerFast, DPRQuestionEncoderTokenizer, DPRQuestionEncoderTokenizerFast
from transformers.models.bart.configuration_bart import BartConfig
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES as DPR_VOCAB_FILES_NAMES
from transformers.models.dpr.configuration_dpr import DPRConfig
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES as BART_VOCAB_FILES_NAMES
from transformers.testing_utils import require_faiss, require_tokenizers, require_torch, slow
from transformers.utils import is_datasets_available, is_faiss_available, is_torch_available


if is_torch_available() and is_datasets_available() and is_faiss_available():
   from transformers.models.rag.configuration_rag import RagConfig
   from transformers.models.rag.tokenization_rag import RagTokenizer


@require_faiss
@require_torch
class   snake_case_ (__SCREAMING_SNAKE_CASE  ):




       """simple docstring"""






       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	List[str]				      =		tempfile.mkdtemp()
             UpperCAmelCase_  :	List[str]				      =		8

             # DPR tok
             UpperCAmelCase_  :	str				      =		[
                 '''[UNK]''',
                 '''[CLS]''',
                 '''[SEP]''',
                 '''[PAD]''',
                 '''[MASK]''',
                 '''want''',
                 '''##want''',
                 '''##ed''',
                 '''wa''',
                 '''un''',
                 '''runn''',
                 '''##ing''',
                 ''',''',
                 '''low''',
                 '''lowest''',
             ]
             UpperCAmelCase_  :	Dict				      =		os.path.join(self.tmpdirname     ,"dpr_tokenizer")
             os.makedirs(__snake_case     ,exist_ok=__snake_case)
             UpperCAmelCase_  :	List[str]				      =		os.path.join(__snake_case     ,DPR_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]))

             # BART tok
             UpperCAmelCase_  :	Any				      =		[
                 '''l''',
                 '''o''',
                 '''w''',
                 '''e''',
                 '''r''',
                 '''s''',
                 '''t''',
                 '''i''',
                 '''d''',
                 '''n''',
                 '''\u0120''',
                 '''\u0120l''',
                 '''\u0120n''',
                 '''\u0120lo''',
                 '''\u0120low''',
                 '''er''',
                 '''\u0120lowest''',
                 '''\u0120newer''',
                 '''\u0120wider''',
                 '''<unk>''',
             ]
             UpperCAmelCase_  :	List[str]				      =		dict(zip(__snake_case     ,range(len(__snake_case))))
             UpperCAmelCase_  :	Any				      =		['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
             UpperCAmelCase_  :	Any				      =		{'''unk_token''': '''<unk>'''}

             UpperCAmelCase_  :	Tuple				      =		os.path.join(self.tmpdirname     ,"bart_tokenizer")
             os.makedirs(__snake_case     ,exist_ok=__snake_case)
             UpperCAmelCase_  :	Dict				      =		os.path.join(__snake_case     ,BART_VOCAB_FILES_NAMES["vocab_file"])
             UpperCAmelCase_  :	Optional[int]				      =		os.path.join(__snake_case     ,BART_VOCAB_FILES_NAMES["merges_file"])
             with open(self.vocab_file     ,"w"     ,encoding="utf-8") as fp:
                   fp.write(json.dumps(__snake_case) + "\n")
             with open(self.merges_file     ,"w"     ,encoding="utf-8") as fp:
                   fp.write("\n".join(__snake_case))



       def  A_   (     self):

             """simple docstring"""





             return DPRQuestionEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname     ,"dpr_tokenizer"))



       def  A_   (     self):

             """simple docstring"""





             return BartTokenizer.from_pretrained(os.path.join(self.tmpdirname     ,"bart_tokenizer"))



       def  A_   (     self):

             """simple docstring"""





             shutil.rmtree(self.tmpdirname)



       @require_tokenizers
       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	Tuple				      =		os.path.join(self.tmpdirname     ,"rag_tokenizer")
             UpperCAmelCase_  :	Union[str, Any]				      =		RagConfig(question_encoder=DPRConfig().to_dict()     ,generator=BartConfig().to_dict())
             UpperCAmelCase_  :	Union[str, Any]				      =		RagTokenizer(question_encoder=self.get_dpr_tokenizer()     ,generator=self.get_bart_tokenizer())
             rag_config.save_pretrained(__snake_case)
             rag_tokenizer.save_pretrained(__snake_case)
             UpperCAmelCase_  :	int				      =		RagTokenizer.from_pretrained(__snake_case     ,config=__snake_case)
             self.assertIsInstance(new_rag_tokenizer.question_encoder     ,__snake_case)
             self.assertEqual(new_rag_tokenizer.question_encoder.get_vocab()     ,rag_tokenizer.question_encoder.get_vocab())
             self.assertIsInstance(new_rag_tokenizer.generator     ,__snake_case)
             self.assertEqual(new_rag_tokenizer.generator.get_vocab()     ,rag_tokenizer.generator.get_vocab())



       @slow
       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	Optional[int]				      =		RagTokenizer.from_pretrained("facebook/rag-token-nq")
             UpperCAmelCase_  :	Any				      =		[
                 '''who got the first nobel prize in physics''',
                 '''when is the next deadpool movie being released''',
                 '''which mode is used for short wave broadcast service''',
                 '''who is the owner of reading football club''',
                 '''when is the next scandal episode coming out''',
                 '''when is the last time the philadelphia won the superbowl''',
                 '''what is the most current adobe flash player version''',
                 '''how many episodes are there in dragon ball z''',
                 '''what is the first step in the evolution of the eye''',
                 '''where is gall bladder situated in human body''',
                 '''what is the main mineral in lithium batteries''',
                 '''who is the president of usa right now''',
                 '''where do the greasers live in the outsiders''',
                 '''panda is a national animal of which country''',
                 '''what is the name of manchester united stadium''',
             ]
             UpperCAmelCase_  :	Dict				      =		tokenizer(__snake_case)
             self.assertIsNotNone(__snake_case)



       @slow
       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	Dict				      =		RagTokenizer.from_pretrained("facebook/rag-sequence-nq")
             UpperCAmelCase_  :	List[Any]				      =		[
                 '''who got the first nobel prize in physics''',
                 '''when is the next deadpool movie being released''',
                 '''which mode is used for short wave broadcast service''',
                 '''who is the owner of reading football club''',
                 '''when is the next scandal episode coming out''',
                 '''when is the last time the philadelphia won the superbowl''',
                 '''what is the most current adobe flash player version''',
                 '''how many episodes are there in dragon ball z''',
                 '''what is the first step in the evolution of the eye''',
                 '''where is gall bladder situated in human body''',
                 '''what is the main mineral in lithium batteries''',
                 '''who is the president of usa right now''',
                 '''where do the greasers live in the outsiders''',
                 '''panda is a national animal of which country''',
                 '''what is the name of manchester united stadium''',
             ]
             UpperCAmelCase_  :	str				      =		tokenizer(__snake_case)
             self.assertIsNotNone(__snake_case)








import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
   import torch

   from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin


class   snake_case_ :




       """simple docstring"""






       def __init__(     self     ,lowercase     ,lowercase=None     ,lowercase=None     ,lowercase=None     ,lowercase="resnet50"     ,lowercase=3     ,lowercase=32     ,lowercase=3     ,lowercase=True     ,lowercase=True     ,):

             """simple docstring"""





             UpperCAmelCase_  :	Union[str, Any]				      =		parent
             UpperCAmelCase_  :	int				      =		out_indices if out_indices is not None else [4]
             UpperCAmelCase_  :	Any				      =		stage_names
             UpperCAmelCase_  :	List[Any]				      =		out_features
             UpperCAmelCase_  :	List[str]				      =		backbone
             UpperCAmelCase_  :	Union[str, Any]				      =		batch_size
             UpperCAmelCase_  :	int				      =		image_size
             UpperCAmelCase_  :	str				      =		num_channels
             UpperCAmelCase_  :	Optional[Any]				      =		use_pretrained_backbone
             UpperCAmelCase_  :	Optional[int]				      =		is_training



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	int				      =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])
             UpperCAmelCase_  :	Dict				      =		self.get_config()

             return config, pixel_values



       def  A_   (     self):

             """simple docstring"""





             return TimmBackboneConfig(
                 image_size=self.image_size     ,num_channels=self.num_channels     ,out_features=self.out_features     ,out_indices=self.out_indices     ,stage_names=self.stage_names     ,use_pretrained_backbone=self.use_pretrained_backbone     ,backbone=self.backbone     ,)



       def  A_   (     self     ,lowercase     ,lowercase):

             """simple docstring"""





             UpperCAmelCase_  :	List[Any]				      =		TimmBackbone(config=lowercase)
             model.to(lowercase)
             model.eval()
             with torch.no_grad():
                   UpperCAmelCase_  :	Union[str, Any]				      =		model(lowercase)
             self.parent.assertEqual(
                 result.feature_map[-1].shape     ,(self.batch_size, model.channels[-1], 14, 14)     ,)



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	Tuple				      =		self.prepare_config_and_inputs()
             UpperCAmelCase_      ,      UpperCAmelCase_  :	Optional[int]				      =		config_and_inputs
             UpperCAmelCase_  :	Union[str, Any]				      =		{"pixel_values": pixel_values}
             return config, inputs_dict


@require_torch
@require_timm
class   snake_case_ (lowercase__ , lowercase__ , lowercase__ , unittest.TestCase  ):




       """simple docstring"""






       _lowerCamelCase			    =				(TimmBackbone,) if is_torch_available() else ()
       _lowerCamelCase			    =				{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
       _lowerCamelCase			    =				False
       _lowerCamelCase			    =				False
       _lowerCamelCase			    =				False
       _lowerCamelCase			    =				False



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	Union[str, Any]				      =		TimmBackboneModelTester(self)
             UpperCAmelCase_  :	Tuple				      =		ConfigTester(self     ,config_class=lowercase     ,has_text_modality=lowercase)



       def  A_   (     self):

             """simple docstring"""





             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  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_  :	int				      =		"resnet18"
             UpperCAmelCase_  :	Tuple				      =		"microsoft/resnet-18"

             UpperCAmelCase_  :	int				      =		AutoBackbone.from_pretrained(lowercase     ,use_timm_backbone=lowercase)
             UpperCAmelCase_  :	Dict				      =		AutoBackbone.from_pretrained(lowercase)

             self.assertEqual(len(timm_model.out_features)     ,len(transformers_model.out_features))
             self.assertEqual(len(timm_model.stage_names)     ,len(transformers_model.stage_names))
             self.assertEqual(timm_model.channels     ,transformers_model.channels)
             # Out indices are set to the last layer by default. For timm models, we don't know
             # the number of layers in advance, so we set it to (-1,), whereas for transformers
             # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
             self.assertEqual(timm_model.out_indices     ,(-1,))
             self.assertEqual(transformers_model.out_indices     ,[len(timm_model.stage_names) - 1])

             UpperCAmelCase_  :	Dict				      =		AutoBackbone.from_pretrained(lowercase     ,use_timm_backbone=lowercase     ,out_indices=[1, 2, 3])
             UpperCAmelCase_  :	List[str]				      =		AutoBackbone.from_pretrained(lowercase     ,out_indices=[1, 2, 3])

             self.assertEqual(timm_model.out_indices     ,transformers_model.out_indices)
             self.assertEqual(len(timm_model.out_features)     ,len(transformers_model.out_features))
             self.assertEqual(timm_model.channels     ,transformers_model.channels)



       @unittest.skip("TimmBackbone doesn't support feed forward chunking")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("TimmBackbone doesn't have num_hidden_layers attribute")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("TimmBackbone initialization is managed on the timm side")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("TimmBackbone models doesn't have inputs_embeds")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("TimmBackbone models doesn't have inputs_embeds")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("TimmBackbone model cannot be created without specifying a backbone checkpoint")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("Only checkpoints on timm can be loaded into TimmBackbone")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("model weights aren't tied in TimmBackbone.")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("model weights aren't tied in TimmBackbone.")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("Only checkpoints on timm can be loaded into TimmBackbone")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("Only checkpoints on timm can be loaded into TimmBackbone")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("TimmBackbone doesn't have hidden size info in its configuration.")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("TimmBackbone doesn't support output_attentions.")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("Safetensors is not supported by timm.")
       def  A_   (     self):

             """simple docstring"""





             pass



       @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests.")
       def  A_   (     self):

             """simple docstring"""





             pass



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_      ,      UpperCAmelCase_  :	int				      =		self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   UpperCAmelCase_  :	Union[str, Any]				      =		model_class(lowercase)
                   UpperCAmelCase_  :	Optional[Any]				      =		inspect.signature(model.forward)
                   # signature.parameters is an OrderedDict => so arg_names order is deterministic
                   UpperCAmelCase_  :	str				      =		[*signature.parameters.keys()]

                   UpperCAmelCase_  :	Any				      =		["pixel_values"]
                   self.assertListEqual(arg_names[:1]     ,lowercase)



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_      ,      UpperCAmelCase_  :	Tuple				      =		self.model_tester.prepare_config_and_inputs_for_common()
             UpperCAmelCase_  :	Dict				      =		True
             UpperCAmelCase_  :	str				      =		self.has_attentions

             # no need to test all models as different heads yield the same functionality
             UpperCAmelCase_  :	str				      =		self.all_model_classes[0]
             UpperCAmelCase_  :	List[Any]				      =		model_class(lowercase)
             model.to(lowercase)

             UpperCAmelCase_  :	Any				      =		self._prepare_for_class(lowercase     ,lowercase)
             UpperCAmelCase_  :	Optional[int]				      =		model(**lowercase)
             UpperCAmelCase_  :	Optional[Any]				      =		outputs[0][-1]

             # Encoder-/Decoder-only models
             UpperCAmelCase_  :	List[Any]				      =		outputs.hidden_states[0]
             hidden_states.retain_grad()

             if self.has_attentions:
                   UpperCAmelCase_  :	int				      =		outputs.attentions[0]
                   attentions.retain_grad()

             output.flatten()[0].backward(retain_graph=lowercase)

             self.assertIsNotNone(hidden_states.grad)

             if self.has_attentions:
                   self.assertIsNotNone(attentions.grad)



       def  A_   (     self):

             """simple docstring"""





             UpperCAmelCase_      ,      UpperCAmelCase_  :	List[Any]				      =		self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   UpperCAmelCase_  :	Any				      =		model_class(lowercase)
                   model.to(lowercase)
                   model.eval()
                   UpperCAmelCase_  :	Tuple				      =		model(**lowercase)

                   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
                   UpperCAmelCase_  :	Tuple				      =		copy.deepcopy(lowercase)
                   UpperCAmelCase_  :	List[Any]				      =		None
                   UpperCAmelCase_  :	Optional[Any]				      =		model_class(lowercase)
                   model.to(lowercase)
                   model.eval()
                   UpperCAmelCase_  :	Tuple				      =		model(**lowercase)

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

                   # Check backbone can be initialized with fresh weights
                   UpperCAmelCase_  :	str				      =		copy.deepcopy(lowercase)
                   UpperCAmelCase_  :	Optional[Any]				      =		False
                   UpperCAmelCase_  :	List[str]				      =		model_class(lowercase)
                   model.to(lowercase)
                   model.eval()
                   UpperCAmelCase_  :	Union[str, Any]				      =		model(**lowercase)
