


'''simple docstring'''







from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
   import PIL


A__:    Optional[int]					    =       logging.get_logger(__name__)







class A__       (						UpperCAmelCase__      ):
      __UpperCamelCase       :  Optional[Any]	       =							["pixel_values"]






      def __init__( self			:Dict     ,						SCREAMING_SNAKE_CASE			:bool = True     ,						SCREAMING_SNAKE_CASE			:Dict[str, int] = None     ,						SCREAMING_SNAKE_CASE			:int = 0.9     ,						SCREAMING_SNAKE_CASE			:PILImageResampling = PILImageResampling.BICUBIC     ,						SCREAMING_SNAKE_CASE			:bool = True     ,						SCREAMING_SNAKE_CASE			:Dict[str, int] = None     ,						SCREAMING_SNAKE_CASE			:Union[int, float] = 1 / 2_5_5     ,						SCREAMING_SNAKE_CASE			:bool = True     ,						SCREAMING_SNAKE_CASE			:bool = True     ,						SCREAMING_SNAKE_CASE			:Optional[Union[float, List[float]]] = None     ,						SCREAMING_SNAKE_CASE			:Optional[Union[float, List[float]]] = None     ,						**SCREAMING_SNAKE_CASE			:Union[str, Any]     ,						)       ->					None:




             '''simple docstring'''
             super().__init__(**SCREAMING_SNAKE_CASE	)
             _a    : Optional[Any]     					=size if size is not None else {"""shortest_edge""": 2_2_4}
             _a    : Union[str, Any]     					=get_size_dict(SCREAMING_SNAKE_CASE     ,						default_to_square=SCREAMING_SNAKE_CASE	)
             _a    : List[str]     					=crop_size if crop_size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
             _a    : Dict     					=get_size_dict(SCREAMING_SNAKE_CASE     ,						param_name="""crop_size"""	)

             _a    : Tuple     					=do_resize
             _a    : List[Any]     					=size
             _a    : List[Any]     					=crop_pct
             _a    : str     					=resample
             _a    : int     					=do_center_crop
             _a    : Optional[int]     					=crop_size
             _a    : Optional[Any]     					=do_rescale
             _a    : str     					=rescale_factor
             _a    : Any     					=do_normalize
             _a    : Any     					=image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
             _a    : Tuple     					=image_std if image_std is not None else IMAGENET_DEFAULT_STD






      def __UpperCAmelCase       ( self			:Tuple     ,						SCREAMING_SNAKE_CASE			:np.ndarray     ,						SCREAMING_SNAKE_CASE			:Dict[str, int]     ,						SCREAMING_SNAKE_CASE			:Optional[float] = None     ,						SCREAMING_SNAKE_CASE			:PILImageResampling = PILImageResampling.BICUBIC     ,						SCREAMING_SNAKE_CASE			:Optional[Union[str, ChannelDimension]] = None     ,						**SCREAMING_SNAKE_CASE			:List[str]     ,						)       ->					np.ndarray:




             '''simple docstring'''
             _a    : Union[str, Any]     					=get_size_dict(SCREAMING_SNAKE_CASE     ,						default_to_square=SCREAMING_SNAKE_CASE	)
             if "shortest_edge" not in size and ("height" not in size or "width" not in size):
                    raise ValueError(f"size must contain 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"	)
             if crop_pct is not None:
                    if "shortest_edge" in size:
                           _a    : List[str]     					=int(size["""shortest_edge"""] / crop_pct	)
                    elif "height" in size and "width" in size:
                           if size["height"] == size["width"]:
                                  _a    : Union[str, Any]     					=int(size["""height"""] / crop_pct	)
                           else:
                                  _a    : Optional[int]     					=(int(size["""height"""] / crop_pct	), int(size["""width"""] / crop_pct	))
                    else:
                           raise ValueError("""Invalid size for resize: {}""".format(SCREAMING_SNAKE_CASE	)	)

                    _a    : int     					=get_resize_output_image_size(SCREAMING_SNAKE_CASE     ,						size=SCREAMING_SNAKE_CASE     ,						default_to_square=SCREAMING_SNAKE_CASE	)
             else:
                    if "shortest_edge" in size:
                           _a    : Tuple     					=get_resize_output_image_size(SCREAMING_SNAKE_CASE     ,						size=size["""shortest_edge"""]     ,						default_to_square=SCREAMING_SNAKE_CASE	)
                    elif "height" in size and "width" in size:
                           _a    : List[str]     					=(size["""height"""], size["""width"""])
                    else:
                           raise ValueError("""Invalid size for resize: {}""".format(SCREAMING_SNAKE_CASE	)	)

             return resize(SCREAMING_SNAKE_CASE     ,						size=SCREAMING_SNAKE_CASE     ,						resample=SCREAMING_SNAKE_CASE     ,						data_format=SCREAMING_SNAKE_CASE     ,						**SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:str     ,						SCREAMING_SNAKE_CASE			:np.ndarray     ,						SCREAMING_SNAKE_CASE			:Dict[str, int]     ,						SCREAMING_SNAKE_CASE			:Optional[Union[str, ChannelDimension]] = None     ,						**SCREAMING_SNAKE_CASE			:str     ,						)       ->					np.ndarray:




             '''simple docstring'''
             _a    : Optional[Any]     					=get_size_dict(SCREAMING_SNAKE_CASE	)
             if "height" not in size or "width" not in size:
                    raise ValueError(f"size must contain 'height' and 'width' as keys. Got {size.keys()}"	)
             return center_crop(SCREAMING_SNAKE_CASE     ,						size=(size["""height"""], size["""width"""])     ,						data_format=SCREAMING_SNAKE_CASE     ,						**SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:Union[str, Any]     ,						SCREAMING_SNAKE_CASE			:np.ndarray     ,						SCREAMING_SNAKE_CASE			:Union[int, float]     ,						SCREAMING_SNAKE_CASE			:Optional[Union[str, ChannelDimension]] = None     ,						**SCREAMING_SNAKE_CASE			:str     ,						)       ->					Optional[int]:




             '''simple docstring'''
             return rescale(SCREAMING_SNAKE_CASE     ,						scale=SCREAMING_SNAKE_CASE     ,						data_format=SCREAMING_SNAKE_CASE     ,						**SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:Any     ,						SCREAMING_SNAKE_CASE			:np.ndarray     ,						SCREAMING_SNAKE_CASE			:Union[float, List[float]]     ,						SCREAMING_SNAKE_CASE			:Union[float, List[float]]     ,						SCREAMING_SNAKE_CASE			:Optional[Union[str, ChannelDimension]] = None     ,						**SCREAMING_SNAKE_CASE			:Optional[int]     ,						)       ->					np.ndarray:




             '''simple docstring'''
             return normalize(SCREAMING_SNAKE_CASE     ,						mean=SCREAMING_SNAKE_CASE     ,						std=SCREAMING_SNAKE_CASE     ,						data_format=SCREAMING_SNAKE_CASE     ,						**SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:Any     ,						SCREAMING_SNAKE_CASE			:ImageInput     ,						SCREAMING_SNAKE_CASE			:bool = None     ,						SCREAMING_SNAKE_CASE			:Dict[str, int] = None     ,						SCREAMING_SNAKE_CASE			:int = None     ,						SCREAMING_SNAKE_CASE			:PILImageResampling = None     ,						SCREAMING_SNAKE_CASE			:bool = None     ,						SCREAMING_SNAKE_CASE			:Dict[str, int] = None     ,						SCREAMING_SNAKE_CASE			:bool = None     ,						SCREAMING_SNAKE_CASE			:float = None     ,						SCREAMING_SNAKE_CASE			:bool = None     ,						SCREAMING_SNAKE_CASE			:Optional[Union[float, List[float]]] = None     ,						SCREAMING_SNAKE_CASE			:Optional[Union[float, List[float]]] = None     ,						SCREAMING_SNAKE_CASE			:Optional[Union[str, TensorType]] = None     ,						SCREAMING_SNAKE_CASE			:ChannelDimension = ChannelDimension.FIRST     ,						**SCREAMING_SNAKE_CASE			:Union[str, Any]     ,						)       ->					PIL.Image.Image:




             '''simple docstring'''
             _a    : int     					=do_resize if do_resize is not None else self.do_resize
             _a    : int     					=crop_pct if crop_pct is not None else self.crop_pct
             _a    : Optional[int]     					=resample if resample is not None else self.resample
             _a    : List[Any]     					=do_center_crop if do_center_crop is not None else self.do_center_crop
             _a    : Tuple     					=do_rescale if do_rescale is not None else self.do_rescale
             _a    : Dict     					=rescale_factor if rescale_factor is not None else self.rescale_factor
             _a    : Tuple     					=do_normalize if do_normalize is not None else self.do_normalize
             _a    : Optional[Any]     					=image_mean if image_mean is not None else self.image_mean
             _a    : Any     					=image_std if image_std is not None else self.image_std

             _a    : Union[str, Any]     					=size if size is not None else self.size
             _a    : Optional[Any]     					=get_size_dict(SCREAMING_SNAKE_CASE     ,						default_to_square=SCREAMING_SNAKE_CASE	)
             _a    : Optional[int]     					=crop_size if crop_size is not None else self.crop_size
             _a    : int     					=get_size_dict(SCREAMING_SNAKE_CASE     ,						param_name="""crop_size"""	)

             _a    : int     					=make_list_of_images(SCREAMING_SNAKE_CASE	)

             if not valid_images(SCREAMING_SNAKE_CASE	):
                    raise ValueError(
                        """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
                        """torch.Tensor, tf.Tensor or jax.ndarray."""	)

             if do_resize and size is None or resample is None:
                    raise ValueError("""Size and resample must be specified if do_resize is True."""	)

             if do_center_crop and crop_pct is None:
                    raise ValueError("""Crop_pct must be specified if do_center_crop is True."""	)

             if do_rescale and rescale_factor is None:
                    raise ValueError("""Rescale factor must be specified if do_rescale is True."""	)

             if do_normalize and (image_mean is None or image_std is None):
                    raise ValueError("""Image mean and std must be specified if do_normalize is True."""	)

             # All transformations expect numpy arrays.
             _a    : Optional[Any]     					=[to_numpy_array(SCREAMING_SNAKE_CASE	) for image in images]

             if do_resize:
                    _a    : List[str]     					=[self.resize(image=SCREAMING_SNAKE_CASE     ,						size=SCREAMING_SNAKE_CASE     ,						crop_pct=SCREAMING_SNAKE_CASE     ,						resample=SCREAMING_SNAKE_CASE	) for image in images]

             if do_center_crop:
                    _a    : str     					=[self.center_crop(image=SCREAMING_SNAKE_CASE     ,						size=SCREAMING_SNAKE_CASE	) for image in images]

             if do_rescale:
                    _a    : Optional[int]     					=[self.rescale(image=SCREAMING_SNAKE_CASE     ,						scale=SCREAMING_SNAKE_CASE	) for image in images]

             if do_normalize:
                    _a    : Optional[int]     					=[self.normalize(image=SCREAMING_SNAKE_CASE     ,						mean=SCREAMING_SNAKE_CASE     ,						std=SCREAMING_SNAKE_CASE	) for image in images]

             _a    : Union[str, Any]     					=[to_channel_dimension_format(SCREAMING_SNAKE_CASE     ,						SCREAMING_SNAKE_CASE	) for image in images]

             _a    : List[Any]     					={"""pixel_values""": images}
             return BatchFeature(data=SCREAMING_SNAKE_CASE     ,						tensor_type=SCREAMING_SNAKE_CASE	)






'''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 A__       :






      def __init__( self			:Tuple     ,						SCREAMING_SNAKE_CASE			:int     ,						SCREAMING_SNAKE_CASE			:Optional[int]=1_3     ,						SCREAMING_SNAKE_CASE			:Optional[int]=7     ,						SCREAMING_SNAKE_CASE			:Tuple=False     ,						SCREAMING_SNAKE_CASE			:Dict=True     ,						SCREAMING_SNAKE_CASE			:Optional[int]=False     ,						SCREAMING_SNAKE_CASE			:Optional[Any]=True     ,						SCREAMING_SNAKE_CASE			:List[str]=3_3     ,						SCREAMING_SNAKE_CASE			:Tuple=3_2     ,						SCREAMING_SNAKE_CASE			:Tuple=5     ,						SCREAMING_SNAKE_CASE			:int=4     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]=3_7     ,						SCREAMING_SNAKE_CASE			:List[str]="gelu"     ,						SCREAMING_SNAKE_CASE			:Optional[Any]=0.1     ,						SCREAMING_SNAKE_CASE			:Tuple=0.1     ,						SCREAMING_SNAKE_CASE			:str=5_1_2     ,						SCREAMING_SNAKE_CASE			:Dict=1_6     ,						SCREAMING_SNAKE_CASE			:Dict=2     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]=0.02     ,						SCREAMING_SNAKE_CASE			:str=3     ,						SCREAMING_SNAKE_CASE			:List[str]=4     ,						SCREAMING_SNAKE_CASE			:List[str]=None     ,						)       ->					Union[str, Any]:




             '''simple docstring'''
             _a    : Union[str, Any]     					=parent
             _a    : List[Any]     					=batch_size
             _a    : Optional[int]     					=seq_length
             _a    : Union[str, Any]     					=is_training
             _a    : List[Any]     					=use_input_mask
             _a    : Optional[int]     					=use_token_type_ids
             _a    : int     					=use_labels
             _a    : List[str]     					=vocab_size
             _a    : List[Any]     					=hidden_size
             _a    : int     					=num_hidden_layers
             _a    : Tuple     					=num_attention_heads
             _a    : Any     					=intermediate_size
             _a    : str     					=hidden_act
             _a    : Union[str, Any]     					=hidden_dropout_prob
             _a    : Union[str, Any]     					=attention_probs_dropout_prob
             _a    : str     					=max_position_embeddings
             _a    : Dict     					=type_vocab_size
             _a    : Tuple     					=type_sequence_label_size
             _a    : Dict     					=initializer_range
             _a    : List[str]     					=num_labels
             _a    : Tuple     					=num_choices
             _a    : int     					=scope






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




             '''simple docstring'''
             _a    : Optional[int]     					=ids_tensor([self.batch_size, self.seq_length]     ,						self.vocab_size	)

             _a    : List[Any]     					=None
             if self.use_input_mask:
                    _a    : Any     					=random_attention_mask([self.batch_size, self.seq_length]	)

             _a    : Optional[int]     					=None
             _a    : str     					=None
             _a    : Dict     					=None
             if self.use_labels:
                    _a    : Dict     					=ids_tensor([self.batch_size]     ,						self.type_sequence_label_size	)
                    _a    : str     					=ids_tensor([self.batch_size, self.seq_length]     ,						self.num_labels	)
                    _a    : List[str]     					=ids_tensor([self.batch_size]     ,						self.num_choices	)

             _a    : List[Any]     					=self.get_config()

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






      def __UpperCAmelCase       ( self			:str	)       ->					Optional[int]:




             '''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			:List[str]     ,						SCREAMING_SNAKE_CASE			:Tuple     ,						SCREAMING_SNAKE_CASE			:Optional[Any]     ,						SCREAMING_SNAKE_CASE			:Any     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:List[str]     ,						SCREAMING_SNAKE_CASE			:int	)       ->					Tuple:




             '''simple docstring'''
             _a    : Any     					=EsmModel(config=SCREAMING_SNAKE_CASE	)
             model.to(SCREAMING_SNAKE_CASE	)
             model.eval()
             _a    : Optional[Any]     					=model(SCREAMING_SNAKE_CASE     ,						attention_mask=SCREAMING_SNAKE_CASE	)
             _a    : Union[str, Any]     					=model(SCREAMING_SNAKE_CASE	)
             _a    : str     					=model(SCREAMING_SNAKE_CASE	)

             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     ,						SCREAMING_SNAKE_CASE			:Any     ,						SCREAMING_SNAKE_CASE			:List[str]     ,						SCREAMING_SNAKE_CASE			:str     ,						SCREAMING_SNAKE_CASE			:Dict     ,						SCREAMING_SNAKE_CASE			:Dict     ,						SCREAMING_SNAKE_CASE			:Optional[Any]	)       ->					Dict:




             '''simple docstring'''
             _a    : str     					=EsmForMaskedLM(config=SCREAMING_SNAKE_CASE	)
             model.to(SCREAMING_SNAKE_CASE	)
             model.eval()
             _a    : Union[str, Any]     					=model(SCREAMING_SNAKE_CASE     ,						attention_mask=SCREAMING_SNAKE_CASE     ,						labels=SCREAMING_SNAKE_CASE	)
             self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.vocab_size)	)






      def __UpperCAmelCase       ( self			:Optional[Any]     ,						SCREAMING_SNAKE_CASE			:Tuple     ,						SCREAMING_SNAKE_CASE			:Optional[Any]     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]     ,						SCREAMING_SNAKE_CASE			:Dict     ,						SCREAMING_SNAKE_CASE			:List[Any]     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]	)       ->					Optional[Any]:




             '''simple docstring'''
             _a    : int     					=self.num_labels
             _a    : Tuple     					=EsmForTokenClassification(config=SCREAMING_SNAKE_CASE	)
             model.to(SCREAMING_SNAKE_CASE	)
             model.eval()
             _a    : Tuple     					=model(SCREAMING_SNAKE_CASE     ,						attention_mask=SCREAMING_SNAKE_CASE     ,						labels=SCREAMING_SNAKE_CASE	)
             self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.num_labels)	)






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




             '''simple docstring'''
             _a    : Optional[Any]     					=self.prepare_config_and_inputs()
             (
                 (
                 _a
             )					,    (
                 _a
             )					,    (
                 _a
             )					,    (
                 _a
             )					,    (
                 _a
             )					,    (
                 _a
             )					,    
             )    : Any     					=config_and_inputs
             _a    : List[Any]     					={"""input_ids""": input_ids, """attention_mask""": input_mask}
             return config, inputs_dict







@require_torch
class A__       (						UpperCAmelCase__ ,     UpperCAmelCase__ ,     unittest.TestCase      ):
      __UpperCamelCase       :  Any	       =							False

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






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




             '''simple docstring'''
             _a    : Dict     					=EsmModelTester(self	)
             _a    : Optional[Any]     					=ConfigTester(self     ,						config_class=SCREAMING_SNAKE_CASE     ,						hidden_size=3_7	)






      def __UpperCAmelCase       ( self			:Tuple	)       ->					List[Any]:




             '''simple docstring'''
             self.config_tester.run_common_tests()






      def __UpperCAmelCase       ( self			:Optional[int]	)       ->					str:




             '''simple docstring'''
             _a    : List[Any]     					=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:List[Any]	)       ->					Dict:




             '''simple docstring'''
             _a    : List[str]     					=self.model_tester.prepare_config_and_inputs()
             for type in ["absolute", "relative_key", "relative_key_query"]:
                    _a    : Dict     					=type
                    self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE	)






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




             '''simple docstring'''
             _a    : Tuple     					=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE	)






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




             '''simple docstring'''
             _a    : str     					=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE	)






      @slow
      def __UpperCAmelCase       ( self			:str	)       ->					Dict:




             '''simple docstring'''
             for model_name in ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    _a    : Union[str, Any]     					=EsmModel.from_pretrained(SCREAMING_SNAKE_CASE	)
                    self.assertIsNotNone(SCREAMING_SNAKE_CASE	)






      def __UpperCAmelCase       ( self			:Tuple	)       ->					int:




             '''simple docstring'''
             _a    : Optional[Any]     					=self.model_tester.prepare_config_and_inputs()[0]
             _a    : Dict     					=EsmEmbeddings(config=SCREAMING_SNAKE_CASE	)

             _a    : Tuple     					=torch.as_tensor([[1_2, 3_1, 1_3, model.padding_idx]]	)
             _a    : Optional[Any]     					=torch.as_tensor(
                 [
                     [
                         0 + model.padding_idx + 1,
                         1 + model.padding_idx + 1,
                         2 + model.padding_idx + 1,
                         model.padding_idx,
                     ]
                 ]	)
             _a    : Any     					=create_position_ids_from_input_ids(SCREAMING_SNAKE_CASE     ,						model.padding_idx	)
             self.assertEqual(position_ids.shape     ,						expected_positions.shape	)
             self.assertTrue(torch.all(torch.eq(SCREAMING_SNAKE_CASE     ,						SCREAMING_SNAKE_CASE	)	)	)






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




             '''simple docstring'''
             _a    : List[Any]     					=self.model_tester.prepare_config_and_inputs()[0]
             _a    : Optional[int]     					=EsmEmbeddings(config=SCREAMING_SNAKE_CASE	)

             _a    : Tuple     					=torch.empty(2     ,						4     ,						3_0	)
             _a    : str     					=[
                 0 + embeddings.padding_idx + 1,
                 1 + embeddings.padding_idx + 1,
                 2 + embeddings.padding_idx + 1,
                 3 + embeddings.padding_idx + 1,
             ]
             _a    : int     					=torch.as_tensor([expected_single_positions, expected_single_positions]	)
             _a    : Any     					=embeddings.create_position_ids_from_inputs_embeds(SCREAMING_SNAKE_CASE	)
             self.assertEqual(position_ids.shape     ,						expected_positions.shape	)
             self.assertTrue(torch.all(torch.eq(SCREAMING_SNAKE_CASE     ,						SCREAMING_SNAKE_CASE	)	)	)






      @unittest.skip("""Esm does not support embedding resizing"""	)
      def __UpperCAmelCase       ( self			:Tuple	)       ->					List[str]:




             '''simple docstring'''
             pass






      @unittest.skip("""Esm does not support embedding resizing"""	)
      def __UpperCAmelCase       ( self			:str	)       ->					Any:




             '''simple docstring'''
             pass






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




             '''simple docstring'''
             pass







@require_torch
class A__       (						UpperCAmelCase__      ):






      @slow
      def __UpperCAmelCase       ( self			:List[Any]	)       ->					str:




             '''simple docstring'''
             with torch.no_grad():
                    _a    : Optional[int]     					=EsmForMaskedLM.from_pretrained("""facebook/esm2_t6_8M_UR50D"""	)
                    model.eval()
                    _a    : Any     					=torch.tensor([[0, 1, 2, 3, 4, 5]]	)
                    _a    : Tuple     					=model(SCREAMING_SNAKE_CASE	)[0]

                    _a    : int     					=3_3

                    _a    : Tuple     					=torch.Size((1, 6, vocab_size)	)
                    self.assertEqual(output.shape     ,						SCREAMING_SNAKE_CASE	)

                    _a    : Union[str, Any]     					=torch.tensor(
                        [[[8.9_215, -10.5_898, -6.4_671], [-6.3_967, -13.9_114, -1.1_212], [-7.7_812, -13.9_516, -3.7_406]]]	)
                    self.assertTrue(torch.allclose(output[:, :3, :3]     ,						SCREAMING_SNAKE_CASE     ,						atol=1e-4	)	)






      @slow
      def __UpperCAmelCase       ( self			:Union[str, Any]	)       ->					Tuple:




             '''simple docstring'''
             with torch.no_grad():
                    _a    : Any     					=EsmModel.from_pretrained("""facebook/esm2_t6_8M_UR50D"""	)
                    model.eval()

                    _a    : Any     					=torch.tensor([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]]	)
                    _a    : int     					=model(SCREAMING_SNAKE_CASE	)[0]
                    # compare the actual values for a slice.
                    _a    : str     					=torch.tensor(
                        [[[0.1_444, 0.5_413, 0.3_248], [0.3_034, 0.0_053, 0.3_108], [0.3_228, -0.2_499, 0.3_415]]]	)
                    self.assertTrue(torch.allclose(output[:, :3, :3]     ,						SCREAMING_SNAKE_CASE     ,						atol=1e-4	)	)


