


'''simple docstring'''

import collections
import importlib.util
import os
import re
from pathlib import Path


lowerCamelCase				:  str    		=      'src/transformers'


# Matches is_xxx_available()
lowerCamelCase				:  str    		=      re.compile(R'is\_([a-z_]*)_available()')
# Catches a one-line _import_struct = {xxx}
lowerCamelCase				:  Union[str, Any]    		=      re.compile(R'^_import_structure\s+=\s+\{([^\}]+)\}')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
lowerCamelCase				:  Tuple    		=      re.compile(R'\s+"\S*":\s+\[([^\]]*)\]')
# Catches a line if not is_foo_available
lowerCamelCase				:  Dict    		=      re.compile(R'^\s*if\s+not\s+is\_[a-z_]*\_available\(\)')
# Catches a line _import_struct["bla"].append("foo")
lowerCamelCase				:  List[Any]    		=      re.compile(R'^\s*_import_structure\["\S*"\]\.append\("(\S*)"\)')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
lowerCamelCase				:  Dict    		=      re.compile(R'^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]')
# Catches a line with an object between quotes and a comma:     "MyModel",
lowerCamelCase				:  Union[str, Any]    		=      re.compile('^\s+"([^"]+)",')
# Catches a line with objects between brackets only:    ["foo", "bar"],
lowerCamelCase				:  Optional[int]    		=      re.compile('^\s+\[([^\]]+)\]')
# Catches a line with from foo import bar, bla, boo
lowerCamelCase				:  List[str]    		=      re.compile(R'\s+from\s+\S*\s+import\s+([^\(\s].*)\n')
# Catches a line with try:
lowerCamelCase				:  List[str]    		=      re.compile(R'^\s*try:')
# Catches a line with else:
lowerCamelCase				:  Any    		=      re.compile(R'^\s*else:')

def _SCREAMING_SNAKE_CASE (A			)			->			Tuple:






       """simple docstring"""







       if _re_test_backend.search(A			) is None:
              return None
       lowercase__      =					[b[0] for b in _re_backend.findall(A			)]
       backends.sort()
       return "_and_".join(A			)

def _SCREAMING_SNAKE_CASE (A			)			->			List[Any]:






       """simple docstring"""







       with open(A    ,					'''r'''    ,					encoding='''utf-8'''    ,					newline='''\n'''			) as f:
              lowercase__      =					f.readlines()

       lowercase__      =					0
       while line_index < len(A			) and not lines[line_index].startswith('''_import_structure = {'''			):
              line_index += 1

       # If this is a traditional init, just return.
       if line_index >= len(A			):
              return None

       # First grab the objects without a specific backend in _import_structure
       lowercase__      =					[]
       while not lines[line_index].startswith('''if TYPE_CHECKING'''			) and find_backend(lines[line_index]			) is None:
              lowercase__      =					lines[line_index]
              # If we have everything on a single line, let's deal with it.
              if _re_one_line_import_struct.search(A			):
                     lowercase__      =					_re_one_line_import_struct.search(A			).groups()[0]
                     lowercase__      =					re.findall('''\[([^\]]+)\]'''    ,					A			)
                     for imp in imports:
                            objects.extend([obj[1:-1] for obj in imp.split(''', '''			)]			)
                     line_index += 1
                     continue
              lowercase__      =					_re_import_struct_key_value.search(A			)
              if single_line_import_search is not None:
                     lowercase__      =					[obj[1:-1] for obj in single_line_import_search.groups()[0].split(''', '''			) if len(A			) > 0]
                     objects.extend(A			)
              elif line.startswith(''' ''' * 8 + '''"'''			):
                     objects.append(line[9:-3]			)
              line_index += 1

       lowercase__      =					{'''none''': objects}
       # Let's continue with backend-specific objects in _import_structure
       while not lines[line_index].startswith('''if TYPE_CHECKING'''			):
              # If the line is an if not is_backend_available, we grab all objects associated.
              lowercase__      =					find_backend(lines[line_index]			)
              # Check if the backend declaration is inside a try block:
              if _re_try.search(lines[line_index - 1]			) is None:
                     lowercase__      =					None

              if backend is not None:
                     line_index += 1

                     # Scroll until we hit the else block of try-except-else
                     while _re_else.search(lines[line_index]			) is None:
                            line_index += 1

                     line_index += 1

                     lowercase__      =					[]
                     # Until we unindent, add backend objects to the list
                     while len(lines[line_index]			) <= 1 or lines[line_index].startswith(''' ''' * 4			):
                            lowercase__      =					lines[line_index]
                            if _re_import_struct_add_one.search(A			) is not None:
                                   objects.append(_re_import_struct_add_one.search(A			).groups()[0]			)
                            elif _re_import_struct_add_many.search(A			) is not None:
                                   lowercase__      =					_re_import_struct_add_many.search(A			).groups()[0].split(''', '''			)
                                   lowercase__      =					[obj[1:-1] for obj in imports if len(A			) > 0]
                                   objects.extend(A			)
                            elif _re_between_brackets.search(A			) is not None:
                                   lowercase__      =					_re_between_brackets.search(A			).groups()[0].split(''', '''			)
                                   lowercase__      =					[obj[1:-1] for obj in imports if len(A			) > 0]
                                   objects.extend(A			)
                            elif _re_quote_object.search(A			) is not None:
                                   objects.append(_re_quote_object.search(A			).groups()[0]			)
                            elif line.startswith(''' ''' * 8 + '''"'''			):
                                   objects.append(line[9:-3]			)
                            elif line.startswith(''' ''' * 12 + '''"'''			):
                                   objects.append(line[13:-3]			)
                            line_index += 1

                     lowercase__      =					objects
              else:
                     line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
       lowercase__      =					[]
       while (
           line_index < len(A			)
           and find_backend(lines[line_index]			) is None
           and not lines[line_index].startswith('''else'''			)
       ):
              lowercase__      =					lines[line_index]
              lowercase__      =					_re_import.search(A			)
              if single_line_import_search is not None:
                     objects.extend(single_line_import_search.groups()[0].split(''', '''			)			)
              elif line.startswith(''' ''' * 8			):
                     objects.append(line[8:-2]			)
              line_index += 1

       lowercase__      =					{'''none''': objects}
       # Let's continue with backend-specific objects
       while line_index < len(A			):
              # If the line is an if is_backend_available, we grab all objects associated.
              lowercase__      =					find_backend(lines[line_index]			)
              # Check if the backend declaration is inside a try block:
              if _re_try.search(lines[line_index - 1]			) is None:
                     lowercase__      =					None

              if backend is not None:
                     line_index += 1

                     # Scroll until we hit the else block of try-except-else
                     while _re_else.search(lines[line_index]			) is None:
                            line_index += 1

                     line_index += 1

                     lowercase__      =					[]
                     # Until we unindent, add backend objects to the list
                     while len(lines[line_index]			) <= 1 or lines[line_index].startswith(''' ''' * 8			):
                            lowercase__      =					lines[line_index]
                            lowercase__      =					_re_import.search(A			)
                            if single_line_import_search is not None:
                                   objects.extend(single_line_import_search.groups()[0].split(''', '''			)			)
                            elif line.startswith(''' ''' * 12			):
                                   objects.append(line[12:-2]			)
                            line_index += 1

                     lowercase__      =					objects
              else:
                     line_index += 1

       return import_dict_objects, type_hint_objects

def _SCREAMING_SNAKE_CASE (A    ,					A			)			->			Any:






       """simple docstring"""







       def find_duplicates(A			):
              return [k for k, v in collections.Counter(A			).items() if v > 1]

       if list(import_dict_objects.keys()			) != list(type_hint_objects.keys()			):
              return ["Both sides of the init do not have the same backends!"]

       lowercase__      =					[]
       for key in import_dict_objects.keys():
              lowercase__      =					find_duplicates(import_dict_objects[key]			)
              if duplicate_imports:
                     errors.append(f"Duplicate _import_structure definitions for: {duplicate_imports}"			)
              lowercase__      =					find_duplicates(type_hint_objects[key]			)
              if duplicate_type_hints:
                     errors.append(f"Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}"			)

              if sorted(set(import_dict_objects[key]			)			) != sorted(set(type_hint_objects[key]			)			):
                     lowercase__      =					'''base imports''' if key == '''none''' else f"{key} backend"
                     errors.append(f"Differences for {name}:"			)
                     for a in type_hint_objects[key]:
                            if a not in import_dict_objects[key]:
                                   errors.append(f"  {a} in TYPE_HINT but not in _import_structure."			)
                     for a in import_dict_objects[key]:
                            if a not in type_hint_objects[key]:
                                   errors.append(f"  {a} in _import_structure but not in TYPE_HINT."			)
       return errors

def _SCREAMING_SNAKE_CASE ()			->			Any:






       """simple docstring"""







       lowercase__      =					[]
       for root, _, files in os.walk(A			):
              if "__init__.py" in files:
                     lowercase__      =					os.path.join(A    ,					'''__init__.py'''			)
                     lowercase__      =					parse_init(A			)
                     if objects is not None:
                            lowercase__      =					analyze_results(*A			)
                            if len(A			) > 0:
                                   lowercase__      =					f"Problem in {fname}, both halves do not define the same objects.\n{errors[0]}"
                                   failures.append('''\n'''.join(A			)			)
       if len(A			) > 0:
              raise ValueError('''\n\n'''.join(A			)			)

def _SCREAMING_SNAKE_CASE ()			->			str:






       """simple docstring"""







       lowercase__      =					[]
       for path, directories, files in os.walk(A			):
              for folder in directories:
                     # Ignore private modules
                     if folder.startswith('''_'''			):
                            directories.remove(A			)
                            continue
                     # Ignore leftovers from branches (empty folders apart from pycache)
                     if len(list((Path(A			) / folder).glob('''*.py'''			)			)			) == 0:
                            continue
                     lowercase__      =					str((Path(A			) / folder).relative_to(A			)			)
                     lowercase__      =					short_path.replace(os.path.sep    ,					'''.'''			)
                     submodules.append(A			)
              for fname in files:
                     if fname == "__init__.py":
                            continue
                     lowercase__      =					str((Path(A			) / fname).relative_to(A			)			)
                     lowercase__      =					short_path.replace('''.py'''    ,					''''''			).replace(os.path.sep    ,					'''.'''			)
                     if len(submodule.split('''.'''			)			) == 1:
                            submodules.append(A			)
       return submodules


lowerCamelCase				:  Dict    		=      [
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
]

def _SCREAMING_SNAKE_CASE ()			->			Any:






       """simple docstring"""







       lowercase__      =					importlib.util.spec_from_file_location(
           '''transformers'''    ,					os.path.join(A    ,					'''__init__.py'''			)    ,					submodule_search_locations=[PATH_TO_TRANSFORMERS]    ,					)
       lowercase__      =					spec.loader.load_module()

       lowercase__      =					[
           module
           for module in get_transformers_submodules()
           if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
       ]
       if len(A			) > 0:
              lowercase__      =					'''\n'''.join(f"- {module}" for module in module_not_registered			)
              raise ValueError(
                  '''The following submodules are not properly registered in the main init of Transformers:\n'''
                  f"{list_of_modules}\n"
                  '''Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value.'''			)


if __name__ == "__main__":
 check_all_inits()
 check_submodules()








'''simple docstring'''

import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import EsmForMaskedLM, EsmForSequenceClassification, EsmForTokenClassification, EsmModel
 from transformers.models.esm.modeling_esm import (
     ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
     EsmEmbeddings,
     create_position_ids_from_input_ids,
 )
class     __lowerCAmelCase		:





      '''simple docstring'''






      def __init__(self       :       Optional[int]  ,		UpperCamelCase       :       Tuple  ,		UpperCamelCase       :       str=13  ,		UpperCamelCase       :       Optional[int]=7  ,		UpperCamelCase       :       Union[str, Any]=False  ,		UpperCamelCase       :       Dict=True  ,		UpperCamelCase       :       Optional[int]=False  ,		UpperCamelCase       :       Optional[Any]=True  ,		UpperCamelCase       :       Union[str, Any]=33  ,		UpperCamelCase       :       List[Any]=32  ,		UpperCamelCase       :       Dict=5  ,		UpperCamelCase       :       str=4  ,		UpperCamelCase       :       str=37  ,		UpperCamelCase       :       List[Any]="gelu"  ,		UpperCamelCase       :       List[str]=0.1  ,		UpperCamelCase       :       Dict=0.1  ,		UpperCamelCase       :       Dict=512  ,		UpperCamelCase       :       Any=16  ,		UpperCamelCase       :       List[Any]=2  ,		UpperCamelCase       :       List[Any]=0.02  ,		UpperCamelCase       :       Tuple=3  ,		UpperCamelCase       :       Optional[Any]=4  ,		UpperCamelCase       :       int=None  ,		):

             '''simple docstring'''







             lowercase__      =					parent
             lowercase__      =					batch_size
             lowercase__      =					seq_length
             lowercase__      =					is_training
             lowercase__      =					use_input_mask
             lowercase__      =					use_token_type_ids
             lowercase__      =					use_labels
             lowercase__      =					vocab_size
             lowercase__      =					hidden_size
             lowercase__      =					num_hidden_layers
             lowercase__      =					num_attention_heads
             lowercase__      =					intermediate_size
             lowercase__      =					hidden_act
             lowercase__      =					hidden_dropout_prob
             lowercase__      =					attention_probs_dropout_prob
             lowercase__      =					max_position_embeddings
             lowercase__      =					type_vocab_size
             lowercase__      =					type_sequence_label_size
             lowercase__      =					initializer_range
             lowercase__      =					num_labels
             lowercase__      =					num_choices
             lowercase__      =					scope



      def  UpperCamelCase__						(self       :       str					):

             '''simple docstring'''







             lowercase__      =					ids_tensor([self.batch_size, self.seq_length]  ,		self.vocab_size					)

             lowercase__      =					None
             if self.use_input_mask:
                    lowercase__      =					random_attention_mask([self.batch_size, self.seq_length]					)

             lowercase__      =					None
             lowercase__      =					None
             lowercase__      =					None
             if self.use_labels:
                    lowercase__      =					ids_tensor([self.batch_size]  ,		self.type_sequence_label_size					)
                    lowercase__      =					ids_tensor([self.batch_size, self.seq_length]  ,		self.num_labels					)
                    lowercase__      =					ids_tensor([self.batch_size]  ,		self.num_choices					)

             lowercase__      =					self.get_config()

             return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels



      def  UpperCamelCase__						(self       :       Optional[Any]					):

             '''simple docstring'''







             return EsmConfig(
                 vocab_size=self.vocab_size  ,		hidden_size=self.hidden_size  ,		pad_token_id=1  ,		num_hidden_layers=self.num_hidden_layers  ,		num_attention_heads=self.num_attention_heads  ,		intermediate_size=self.intermediate_size  ,		hidden_act=self.hidden_act  ,		hidden_dropout_prob=self.hidden_dropout_prob  ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,		max_position_embeddings=self.max_position_embeddings  ,		type_vocab_size=self.type_vocab_size  ,		initializer_range=self.initializer_range  ,		)



      def  UpperCamelCase__						(self       :       Optional[int]  ,		UpperCamelCase       :       Union[str, Any]  ,		UpperCamelCase       :       int  ,		UpperCamelCase       :       List[Any]  ,		UpperCamelCase       :       str  ,		UpperCamelCase       :       str  ,		UpperCamelCase       :       Dict					):

             '''simple docstring'''







             lowercase__      =					EsmModel(config=UpperCamelCase					)
             model.to(UpperCamelCase					)
             model.eval()
             lowercase__      =					model(UpperCamelCase  ,		attention_mask=UpperCamelCase					)
             lowercase__      =					model(UpperCamelCase					)
             lowercase__      =					model(UpperCamelCase					)

             self.parent.assertEqual(result.last_hidden_state.shape  ,		(self.batch_size, self.seq_length, self.hidden_size)					)
             self.parent.assertEqual(result.pooler_output.shape  ,		(self.batch_size, self.hidden_size)					)



      def  UpperCamelCase__						(self       :       str  ,		UpperCamelCase       :       Any  ,		UpperCamelCase       :       Tuple  ,		UpperCamelCase       :       Any  ,		UpperCamelCase       :       List[Any]  ,		UpperCamelCase       :       Optional[Any]  ,		UpperCamelCase       :       Optional[int]					):

             '''simple docstring'''







             lowercase__      =					EsmForMaskedLM(config=UpperCamelCase					)
             model.to(UpperCamelCase					)
             model.eval()
             lowercase__      =					model(UpperCamelCase  ,		attention_mask=UpperCamelCase  ,		labels=UpperCamelCase					)
             self.parent.assertEqual(result.logits.shape  ,		(self.batch_size, self.seq_length, self.vocab_size)					)



      def  UpperCamelCase__						(self       :       Any  ,		UpperCamelCase       :       str  ,		UpperCamelCase       :       List[Any]  ,		UpperCamelCase       :       Tuple  ,		UpperCamelCase       :       int  ,		UpperCamelCase       :       Union[str, Any]  ,		UpperCamelCase       :       List[Any]					):

             '''simple docstring'''







             lowercase__      =					self.num_labels
             lowercase__      =					EsmForTokenClassification(config=UpperCamelCase					)
             model.to(UpperCamelCase					)
             model.eval()
             lowercase__      =					model(UpperCamelCase  ,		attention_mask=UpperCamelCase  ,		labels=UpperCamelCase					)
             self.parent.assertEqual(result.logits.shape  ,		(self.batch_size, self.seq_length, self.num_labels)					)






      def  UpperCamelCase__						(self       :       Optional[Any]					):

             '''simple docstring'''







             lowercase__      =					self.prepare_config_and_inputs()
             (
                 (
                 lowercase__
             )     ,(
                 lowercase__
             )     ,(
                 lowercase__
             )     ,(
                 lowercase__
             )     ,(
                 lowercase__
             )     ,(
                 lowercase__
             )     ,
             )      =					config_and_inputs
             lowercase__      =					{'''input_ids''': input_ids, '''attention_mask''': input_mask}
             return config, inputs_dict






@require_torch
class     __lowerCAmelCase		(lowercase_    ,	lowercase_    ,	unittest.TestCase	):





      '''simple docstring'''






      lowerCAmelCase__   :	Dict       =				False

      lowerCAmelCase__   :	Optional[Any]       =				(
          (
              EsmForMaskedLM,
              EsmModel,
              EsmForSequenceClassification,
              EsmForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      lowerCAmelCase__   :	Optional[int]       =				()
      lowerCAmelCase__   :	Any       =				(
          {
              """feature-extraction""": EsmModel,
              """fill-mask""": EsmForMaskedLM,
              """text-classification""": EsmForSequenceClassification,
              """token-classification""": EsmForTokenClassification,
              """zero-shot""": EsmForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      lowerCAmelCase__   :	Any       =				True



      def  UpperCamelCase__						(self       :       List[Any]					):

             '''simple docstring'''







             lowercase__      =					EsmModelTester(self					)
             lowercase__      =					ConfigTester(self  ,		config_class=UpperCamelCase  ,		hidden_size=37					)



      def  UpperCamelCase__						(self       :       Union[str, Any]					):

             '''simple docstring'''







             self.config_tester.run_common_tests()



      def  UpperCamelCase__						(self       :       Optional[Any]					):

             '''simple docstring'''







             lowercase__      =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*UpperCamelCase					)



      def  UpperCamelCase__						(self       :       Any					):

             '''simple docstring'''







             lowercase__      =					self.model_tester.prepare_config_and_inputs()
             for type in ["absolute", "relative_key", "relative_key_query"]:
                    lowercase__      =					type
                    self.model_tester.create_and_check_model(*UpperCamelCase					)



      def  UpperCamelCase__						(self       :       Optional[int]					):

             '''simple docstring'''







             lowercase__      =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase					)



      def  UpperCamelCase__						(self       :       List[Any]					):

             '''simple docstring'''







             lowercase__      =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_token_classification(*UpperCamelCase					)



      @slow
      def  UpperCamelCase__						(self       :       Union[str, Any]					):

             '''simple docstring'''







             for model_name in ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    lowercase__      =					EsmModel.from_pretrained(UpperCamelCase					)
                    self.assertIsNotNone(UpperCamelCase					)



      def  UpperCamelCase__						(self       :       Optional[int]					):

             '''simple docstring'''







             lowercase__      =					self.model_tester.prepare_config_and_inputs()[0]
             lowercase__      =					EsmEmbeddings(config=UpperCamelCase					)

             lowercase__      =					torch.as_tensor([[12, 31, 13, model.padding_idx]]					)
             lowercase__      =					torch.as_tensor(
                 [
                     [
                         0 + model.padding_idx + 1,
                         1 + model.padding_idx + 1,
                         2 + model.padding_idx + 1,
                         model.padding_idx,
                     ]
                 ]					)
             lowercase__      =					create_position_ids_from_input_ids(UpperCamelCase  ,		model.padding_idx					)
             self.assertEqual(position_ids.shape  ,		expected_positions.shape					)
             self.assertTrue(torch.all(torch.eq(UpperCamelCase  ,		UpperCamelCase					)					)					)



      def  UpperCamelCase__						(self       :       Union[str, Any]					):

             '''simple docstring'''







             lowercase__      =					self.model_tester.prepare_config_and_inputs()[0]
             lowercase__      =					EsmEmbeddings(config=UpperCamelCase					)

             lowercase__      =					torch.empty(2  ,		4  ,		30					)
             lowercase__      =					[
                 0 + embeddings.padding_idx + 1,
                 1 + embeddings.padding_idx + 1,
                 2 + embeddings.padding_idx + 1,
                 3 + embeddings.padding_idx + 1,
             ]
             lowercase__      =					torch.as_tensor([expected_single_positions, expected_single_positions]					)
             lowercase__      =					embeddings.create_position_ids_from_inputs_embeds(UpperCamelCase					)
             self.assertEqual(position_ids.shape  ,		expected_positions.shape					)
             self.assertTrue(torch.all(torch.eq(UpperCamelCase  ,		UpperCamelCase					)					)					)



      @unittest.skip('''Esm does not support embedding resizing'''					)
      def  UpperCamelCase__						(self       :       Optional[int]					):

             '''simple docstring'''







             pass



      @unittest.skip('''Esm does not support embedding resizing'''					)
      def  UpperCamelCase__						(self       :       Optional[Any]					):

             '''simple docstring'''







             pass






      @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''					)
      def  UpperCamelCase__						(self       :       Optional[int]					):

             '''simple docstring'''







             pass






@require_torch
class     __lowerCAmelCase		(lowercase_	):





      '''simple docstring'''






      @slow
      def  UpperCamelCase__						(self       :       Optional[Any]					):

             '''simple docstring'''







             with torch.no_grad():
                    lowercase__      =					EsmForMaskedLM.from_pretrained('''facebook/esm2_t6_8M_UR50D'''					)
                    model.eval()
                    lowercase__      =					torch.tensor([[0, 1, 2, 3, 4, 5]]					)
                    lowercase__      =					model(UpperCamelCase					)[0]

                    lowercase__      =					33

                    lowercase__      =					torch.Size((1, 6, vocab_size)					)
                    self.assertEqual(output.shape  ,		UpperCamelCase					)

                    lowercase__      =					torch.tensor(
                        [[[8.92_15, -10.58_98, -6.46_71], [-6.39_67, -13.91_14, -1.12_12], [-7.78_12, -13.95_16, -3.74_06]]]					)
                    self.assertTrue(torch.allclose(output[:, :3, :3]  ,		UpperCamelCase  ,		atol=1E-4					)					)






      @slow
      def  UpperCamelCase__						(self       :       Optional[Any]					):

             '''simple docstring'''







             with torch.no_grad():
                    lowercase__      =					EsmModel.from_pretrained('''facebook/esm2_t6_8M_UR50D'''					)
                    model.eval()

                    lowercase__      =					torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]					)
                    lowercase__      =					model(UpperCamelCase					)[0]
                    # compare the actual values for a slice.
                    lowercase__      =					torch.tensor(
                        [[[0.14_44, 0.54_13, 0.32_48], [0.30_34, 0.00_53, 0.31_08], [0.32_28, -0.24_99, 0.34_15]]]					)
                    self.assertTrue(torch.allclose(output[:, :3, :3]  ,		UpperCamelCase  ,		atol=1E-4					)					)




