





'''simple docstring'''

import unittest

from transformers.testing_utils import is_torch_available, require_torch, tooslow

from ...generation.test_utils import torch_device
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       CpmAntConfig,
       CpmAntForCausalLM,
       CpmAntModel,
       CpmAntTokenizer,
   )





@require_torch
class lowerCamelCase    :







  def __init__(		self  ,  lowercase__  ,  lowercase__=2  ,  lowercase__=8  ,  lowercase__=True  ,  lowercase__=False  ,  lowercase__=False  ,  lowercase__=False  ,  lowercase__=False  ,  lowercase__=99  ,  lowercase__=32  ,  lowercase__=3  ,  lowercase__=4  ,  lowercase__=37  ,  lowercase__=32  ,  lowercase__=128  ,  lowercase__=8  ,  lowercase__=8  ,  lowercase__=8  ,  lowercase__=1.0  ,  lowercase__=True  ,  )		->    Tuple:






        """simple docstring"""





        _snake_case		:						List[Any]         =  parent
        _snake_case		:						List[Any]         =  batch_size
        _snake_case		:						Union[str, Any]         =  seq_length
        _snake_case		:						Tuple         =  is_training
        _snake_case		:						Dict         =  use_token_type_ids
        _snake_case		:						List[str]         =  use_input_mask
        _snake_case		:						List[str]         =  use_labels
        _snake_case		:						Union[str, Any]         =  use_mc_token_ids
        _snake_case		:						Optional[int]         =  vocab_size
        _snake_case		:						str         =  hidden_size
        _snake_case		:						Dict         =  num_hidden_layers
        _snake_case		:						str         =  num_attention_heads
        _snake_case		:						Union[str, Any]         =  intermediate_size
        _snake_case		:						List[Any]         =  num_buckets
        _snake_case		:						Dict         =  max_distance
        _snake_case		:						List[str]         =  prompt_length
        _snake_case		:						str         =  prompt_types
        _snake_case		:						Optional[int]         =  segment_types
        _snake_case		:						str         =  init_std
        _snake_case		:						List[str]         =  return_dict







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






        """simple docstring"""





        _snake_case		:						str         =  {}
        _snake_case		:						List[str]         =  ids_tensor([self.batch_size, self.seq_length]  ,  self.vocab_size		).type(torch.intaa		)
        _snake_case		:						str         =  False

        _snake_case		:						int         =  self.get_config()

        return (config, input_ids)







  def 					UpperCAmelCase_					(		self		)		->    Any:






        """simple docstring"""





        return CpmAntConfig(
            vocab_size=self.vocab_size  ,  hidden_size=self.hidden_size  ,  num_hidden_layers=self.num_hidden_layers  ,  num_attention_heads=self.num_attention_heads  ,  dim_ff=self.intermediate_size  ,  position_bias_num_buckets=self.num_buckets  ,  position_bias_max_distance=self.max_distance  ,  prompt_types=self.prompt_types  ,  prompt_length=self.prompt_length  ,  segment_types=self.segment_types  ,  use_cache=lowercase__  ,  init_std=self.init_std  ,  return_dict=self.return_dict  ,  )







  def 					UpperCAmelCase_					(		self  ,  lowercase__  ,  lowercase__  ,  *lowercase__		)		->    List[Any]:






        """simple docstring"""





        _snake_case		:						Union[str, Any]         =  CpmAntModel(config=lowercase__		)
        model.to(lowercase__		)
        model.eval()

        _snake_case		:						Optional[Any]         =  model(**lowercase__		).last_hidden_state

        self.parent.assertEqual(hidden_states.shape  ,  (self.batch_size, self.seq_length, config.hidden_size)		)







  def 					UpperCAmelCase_					(		self  ,  lowercase__  ,  lowercase__  ,  *lowercase__		)		->    List[Any]:






        """simple docstring"""





        _snake_case		:						Any         =  CpmAntForCausalLM(lowercase__		)
        model.to(lowercase__		)
        _snake_case		:						Optional[int]         =  input_ids['''input_ids'''].to(lowercase__		)
        model.eval()

        _snake_case		:						Tuple         =  model(**lowercase__		)
        self.parent.assertEqual(
            model_output.logits.shape  ,  (self.batch_size, self.seq_length, config.vocab_size + config.prompt_types * config.prompt_length)  ,  )







  def 					UpperCAmelCase_					(		self		)		->    int:






        """simple docstring"""





        _snake_case  ,				_snake_case		:						Optional[Any]         =  self.prepare_config_and_inputs()
        return config, inputs_dict





@require_torch
class lowerCamelCase    (a__    ,   a__    ,   unittest.TestCase       ):
  _lowercase	:						Optional[int]							       =					(CpmAntModel, CpmAntForCausalLM) if is_torch_available() else ()
  _lowercase	:						List[str]							       =					(
      {"""feature-extraction""": CpmAntModel, """text-generation""": CpmAntForCausalLM} if is_torch_available() else {}
  )

  _lowercase	:						List[str]							       =					False
  _lowercase	:						Optional[int]							       =					False
  _lowercase	:						int							       =					False
  _lowercase	:						Any							       =					False
  _lowercase	:						Any							       =					False







  def 					UpperCAmelCase_					(		self		)		->    int:






        """simple docstring"""





        _snake_case		:						str         =  CpmAntModelTester(self		)
        _snake_case		:						List[str]         =  ConfigTester(self  ,  config_class=lowercase__		)







  def 					UpperCAmelCase_					(		self		)		->    str:






        """simple docstring"""





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







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






        """simple docstring"""





        unittest.skip('''CPMAnt doesn\'t support input_embeds.'''		)(self.test_inputs_embeds		)







  def 					UpperCAmelCase_					(		self		)		->    str:






        """simple docstring"""





        unittest.skip(
            '''CPMAnt doesn\'t support retain grad in hidden_states or attentions, because prompt management will peel off the output.hidden_states from graph.\
                 So is attentions. We strongly recommand you use loss to tune model.'''		)(self.test_retain_grad_hidden_states_attentions		)







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






        """simple docstring"""





        _snake_case  ,				_snake_case		:						List[Any]         =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_cpmant_model(lowercase__  ,  lowercase__		)







  def 					UpperCAmelCase_					(		self		)		->    Tuple:






        """simple docstring"""





        _snake_case  ,				_snake_case		:						str         =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_lm_head_model(lowercase__  ,  lowercase__		)





@require_torch
class lowerCamelCase    (unittest.TestCase       ):







  @tooslow
  def 					UpperCAmelCase_					(		self		)		->    List[Any]:






        """simple docstring"""





        _snake_case		:						List[str]         =  '''今天天气真好！'''
        _snake_case		:						List[str]         =  '''openbmb/cpm-ant-10b'''
        _snake_case		:						Any         =  CpmAntModel.from_pretrained(lowercase__		)
        _snake_case		:						Tuple         =  CpmAntTokenizer.from_pretrained(lowercase__		)
        _snake_case		:						Tuple         =  tokenizer(lowercase__  ,  return_tensors='''pt'''		)
        _snake_case		:						Union[str, Any]         =  model(**lowercase__		).last_hidden_state

        _snake_case		:						int         =  torch.tensor(
            [[[6.1_708, 5.9_244, 1.0_835], [6.5_207, 6.2_893, -11.3_324], [-1.0_107, -0.0_576, -5.9_577]]]  ,  )
        self.assertTrue(torch.allclose(hidden_states[:, :3, :3]  ,  lowercase__  ,  atol=1E-2		)		)





@require_torch
class lowerCamelCase    (unittest.TestCase       ):







  @tooslow
  def 					UpperCAmelCase_					(		self		)		->    Union[str, Any]:






        """simple docstring"""





        _snake_case		:						Optional[Any]         =  '''今天天气真好！'''
        _snake_case		:						Optional[Any]         =  '''openbmb/cpm-ant-10b'''
        _snake_case		:						Dict         =  CpmAntForCausalLM.from_pretrained(lowercase__		)
        _snake_case		:						List[str]         =  CpmAntTokenizer.from_pretrained(lowercase__		)
        _snake_case		:						List[str]         =  tokenizer(lowercase__  ,  return_tensors='''pt'''		)
        _snake_case		:						Dict         =  model(**lowercase__		).logits

        _snake_case		:						List[str]         =  torch.tensor(
            [[[-6.4_267, -6.4_083, -6.3_958], [-5.8_802, -5.9_447, -5.7_811], [-5.3_896, -5.4_820, -5.4_295]]]  ,  )
        self.assertTrue(torch.allclose(hidden_states[:, :3, :3]  ,  lowercase__  ,  atol=1E-2		)		)







  @tooslow
  def 					UpperCAmelCase_					(		self		)		->    Optional[Any]:






        """simple docstring"""





        _snake_case		:						Optional[int]         =  '''openbmb/cpm-ant-10b'''
        _snake_case		:						List[Any]         =  CpmAntForCausalLM.from_pretrained(lowercase__		)
        _snake_case		:						List[Any]         =  CpmAntTokenizer.from_pretrained(lowercase__		)
        _snake_case		:						Any         =  '''今天天气不错，'''
        _snake_case		:						Any         =  '''今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的'''
        _snake_case		:						int         =  tokenizer(lowercase__  ,  return_tensors='''pt'''		)
        _snake_case		:						List[Any]         =  model.generate(**lowercase__		)
        _snake_case		:						List[Any]         =  tokenizer.batch_decode(lowercase__		)
        self.assertEqual(lowercase__  ,  lowercase__		)







  @tooslow
  def 					UpperCAmelCase_					(		self		)		->    Optional[int]:






        """simple docstring"""





        _snake_case		:						List[Any]         =  '''openbmb/cpm-ant-10b'''
        _snake_case		:						Optional[int]         =  CpmAntForCausalLM.from_pretrained(lowercase__		)
        _snake_case		:						Union[str, Any]         =  CpmAntTokenizer.from_pretrained(lowercase__		)
        _snake_case		:						str         =  ['''今天天气不错，''', '''新年快乐，万事如意！''']
        _snake_case		:						str         =  [
            '''今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的''',
            '''新年快乐，万事如意！在这辞旧迎新的美好时刻，我谨代表《农村新技术》杂志社全体同仁，向一直以来关心、支持《农村新技术》杂志发展的各级领导、各界朋友和广大读者致以最诚挚的''',
        ]
        _snake_case		:						int         =  tokenizer(lowercase__  ,  return_tensors='''pt'''  ,  padding=lowercase__		)
        _snake_case		:						str         =  model.generate(**lowercase__		)
        _snake_case		:						Union[str, Any]         =  tokenizer.batch_decode(lowercase__		)
        self.assertEqual(lowercase__  ,  lowercase__		)









'''simple docstring'''

def  _a     (				lowerCAmelCase_ = 4_000_000						):





      """simple docstring"""



      _snake_case		:						Optional[int]         =  1
      _snake_case		:						Tuple         =  2
      _snake_case		:						Optional[Any]         =  0
      while j <= n:
            if j % 2 == 0:
                  total += j
            _snake_case  ,				_snake_case		:						str         =  j, i + j

      return total


if __name__ == "__main__":
   print(F"""{solution() = }""")


