




"""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     __magic_name__							:






				'''simple docstring'''





				def __init__(       self		, _a		, _a=13		, _a=7		, _a=False		, _a=True		, _a=False		, _a=True		, _a=33		, _a=32		, _a=5		, _a=4		, _a=37		, _a="gelu"		, _a=0.1		, _a=0.1		, _a=512		, _a=16		, _a=2		, _a=0.02		, _a=3		, _a=4		, _a=None		, ):





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





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					ids_tensor([self.batch_size, self.seq_length]		, self.vocab_size )

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

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

							lowerCamelCase			      =					self.get_config()

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





				def    _lowerCAmelCase				(       self ):





							"""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    _lowerCAmelCase				(       self		, _a		, _a		, _a		, _a		, _a		, _a ):





							"""simple docstring"""
							lowerCamelCase			      =					EsmModel(config=lowercase_ )
							model.to(lowercase_ )
							model.eval()
							lowerCamelCase			      =					model(lowercase_		, attention_mask=lowercase_ )
							lowerCamelCase			      =					model(lowercase_ )
							lowerCamelCase			      =					model(lowercase_ )

							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    _lowerCAmelCase				(       self		, _a		, _a		, _a		, _a		, _a		, _a ):





							"""simple docstring"""
							lowerCamelCase			      =					EsmForMaskedLM(config=lowercase_ )
							model.to(lowercase_ )
							model.eval()
							lowerCamelCase			      =					model(lowercase_		, attention_mask=lowercase_		, labels=lowercase_ )
							self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.seq_length, self.vocab_size) )





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a		, _a		, _a		, _a ):





							"""simple docstring"""
							lowerCamelCase			      =					self.num_labels
							lowerCamelCase			      =					EsmForTokenClassification(config=lowercase_ )
							model.to(lowercase_ )
							model.eval()
							lowerCamelCase			      =					model(lowercase_		, attention_mask=lowercase_		, labels=lowercase_ )
							self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.seq_length, self.num_labels) )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.prepare_config_and_inputs()
							(
							    (
							    lowerCamelCase						
							)      ,   (
							    lowerCamelCase						
							)      ,   (
							    lowerCamelCase						
							)      ,   (
							    lowerCamelCase						
							)      ,   (
							    lowerCamelCase						
							)      ,   (
							    lowerCamelCase						
							)      ,   						
							)			      =					config_and_inputs
							lowerCamelCase			      =					{"""input_ids""": input_ids, """attention_mask""": input_mask}
							return config, inputs_dict






@require_torch
class     __magic_name__							(       _UpperCAmelCase						,					_UpperCAmelCase						,					unittest.TestCase				):






				'''simple docstring'''
				__UpperCamelCase			  =						False

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





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					EsmModelTester(self )
							lowerCamelCase			      =					ConfigTester(self		, config_class=lowercase_		, hidden_size=37 )





				def    _lowerCAmelCase				(       self ):





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





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowercase_ )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							for type in ["absolute", "relative_key", "relative_key_query"]:
										lowerCamelCase			      =					type
										self.model_tester.create_and_check_model(*lowercase_ )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*lowercase_ )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*lowercase_ )





				@slow
				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""







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





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()[0]
							lowerCamelCase			      =					EsmEmbeddings(config=lowercase_ )

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





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()[0]
							lowerCamelCase			      =					EsmEmbeddings(config=lowercase_ )

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





				@unittest.skip("""Esm does not support embedding resizing""" )
				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							pass





				@unittest.skip("""Esm does not support embedding resizing""" )
				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							pass





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





							"""simple docstring"""
							pass






@require_torch
class     __magic_name__							(       _UpperCAmelCase				):






				'''simple docstring'''





				@slow
				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""







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

										lowerCamelCase			      =					33

										lowerCamelCase			      =					torch.Size((1, 6, vocab_size) )
										self.assertEqual(output.shape		, lowercase_ )

										lowerCamelCase			      =					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]		, lowercase_		, atol=1e-4 ) )





				@slow
				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""







							with torch.no_grad():
										lowerCamelCase			      =					EsmModel.from_pretrained("""facebook/esm2_t6_8M_UR50D""" )
										model.eval()

										lowerCamelCase			      =					torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]] )
										lowerCamelCase			      =					model(lowercase_ )[0]
										# compare the actual values for a slice.
										lowerCamelCase			      =					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]		, lowercase_		, atol=1e-4 ) )






from timeit import timeit
def 						_snake_case(    SCREAMING_SNAKE_CASE__			:	int      )							->      int:





    '''simple docstring'''






    if number < 0:
        raise ValueError('the value of input must not be negative'      )
    A__          =   0
    while number:
        number &= number - 1
        result += 1
    return result
def 						_snake_case(    SCREAMING_SNAKE_CASE__			:	int      )							->      int:





    '''simple docstring'''






    if number < 0:
        raise ValueError('the value of input must not be negative'      )
    A__          =   0
    while number:
        if number % 2 == 1:
            result += 1
        number >>= 1
    return result
def 						_snake_case(    )							->      None:





    '''simple docstring'''






    def do_benchmark(SCREAMING_SNAKE_CASE__			:	int      ) -> None:
        A__          =   'import __main__ as z'
        print(f'Benchmark when {number = }:'      )
        print(f'{get_set_bits_count_using_modulo_operator(SCREAMING_SNAKE_CASE__      ) = }'      )
        A__          =   timeit('z.get_set_bits_count_using_modulo_operator(25)'    ,			setup=SCREAMING_SNAKE_CASE__      )
        print(f'timeit() runs in {timing} seconds'      )
        print(f'{get_set_bits_count_using_brian_kernighans_algorithm(SCREAMING_SNAKE_CASE__      ) = }'      )
        A__          =   timeit(
            'z.get_set_bits_count_using_brian_kernighans_algorithm(25)'    ,			setup=SCREAMING_SNAKE_CASE__    ,			)
        print(f'timeit() runs in {timing} seconds'      )

    for number in (25, 37, 58, 0):
        do_benchmark(SCREAMING_SNAKE_CASE__      )
        print()


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     benchmark()

