code: 
  
  
  
  '''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        UpperCAmelCase__  :
  
  
  
   def __init__(  self		,	lowercase		,	lowercase=2		,	lowercase=8		,	lowercase=True		,	lowercase=False		,	lowercase=False		,	lowercase=False		,	lowercase=False		,	lowercase=9_9		,	lowercase=3_2		,	lowercase=3		,	lowercase=4		,	lowercase=3_7		,	lowercase=3_2		,	lowercase=1_2_8		,	lowercase=8		,	lowercase=8		,	lowercase=8		,	lowercase=1.0		,	lowercase=True		,	)  ->							str:
    __UpperCamelCase				      =  parent
    __UpperCamelCase				      =  batch_size
    __UpperCamelCase				      =  seq_length
    __UpperCamelCase				      =  is_training
    __UpperCamelCase				      =  use_token_type_ids
    __UpperCamelCase				      =  use_input_mask
    __UpperCamelCase				      =  use_labels
    __UpperCamelCase				      =  use_mc_token_ids
    __UpperCamelCase				      =  vocab_size
    __UpperCamelCase				      =  hidden_size
    __UpperCamelCase				      =  num_hidden_layers
    __UpperCamelCase				      =  num_attention_heads
    __UpperCamelCase				      =  intermediate_size
    __UpperCamelCase				      =  num_buckets
    __UpperCamelCase				      =  max_distance
    __UpperCamelCase				      =  prompt_length
    __UpperCamelCase				      =  prompt_types
    __UpperCamelCase				      =  segment_types
    __UpperCamelCase				      =  init_std
    __UpperCamelCase				      =  return_dict
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Optional[int]:
    __UpperCamelCase				      =  {}
    __UpperCamelCase				      =  ids_tensor([self.batch_size, self.seq_length]		,	self.vocab_size			).type(torch.intaa			)
    __UpperCamelCase				      =  False
  
    __UpperCamelCase				      =  self.get_config()
  
    return (config, input_ids)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Optional[int]:
    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    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	*lowercase			)  ->							Any:
    __UpperCamelCase				      =  CpmAntModel(config=lowercase			)
    model.to(lowercase			)
    model.eval()
  
    __UpperCamelCase				      =  model(**lowercase			).last_hidden_state
  
    self.parent.assertEqual(hidden_states.shape		,	(self.batch_size, self.seq_length, config.hidden_size)			)
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	*lowercase			)  ->							Union[str, Any]:
    __UpperCamelCase				      =  CpmAntForCausalLM(lowercase			)
    model.to(lowercase			)
    __UpperCamelCase				      =  input_ids["""input_ids"""].to(lowercase			)
    model.eval()
  
    __UpperCamelCase				      =  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    __lowerCamelCase				(  self			)  ->							Optional[Any]:
    __UpperCamelCase      ,		__UpperCamelCase				      =  self.prepare_config_and_inputs()
    return config, inputs_dict
  
  
  @require_torch
  class        UpperCAmelCase__  (    UpperCAmelCase_							,			UpperCAmelCase_							,			unittest.TestCase):
   __SCREAMING_SNAKE_CASE					      =				(CpmAntModel, CpmAntForCausalLM) if is_torch_available() else ()
   __SCREAMING_SNAKE_CASE					      =				(
       {'''feature-extraction''': CpmAntModel, '''text-generation''': CpmAntForCausalLM} if is_torch_available() else {}
   )
  
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				False
  
  
  
   def    __lowerCamelCase				(  self			)  ->							List[Any]:
    __UpperCamelCase				      =  CpmAntModelTester(self			)
    __UpperCamelCase				      =  ConfigTester(self		,	config_class=lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Tuple:
    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    __lowerCamelCase				(  self			)  ->							Optional[int]:
    unittest.skip("""CPMAnt doesn't support input_embeds."""			)(self.test_inputs_embeds			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Tuple:
    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    __lowerCamelCase				(  self			)  ->							Optional[int]:
    __UpperCamelCase      ,		__UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_cpmant_model(lowercase		,	lowercase			)
  
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Dict:
    __UpperCamelCase      ,		__UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_lm_head_model(lowercase		,	lowercase			)
  
  
  @require_torch
  class        UpperCAmelCase__  (    unittest.TestCase):
  
  
  
   @tooslow
   def    __lowerCamelCase				(  self			)  ->							Optional[Any]:
    __UpperCamelCase				      =  """今天天气真好！"""
    __UpperCamelCase				      =  """openbmb/cpm-ant-10b"""
    __UpperCamelCase				      =  CpmAntModel.from_pretrained(lowercase			)
    __UpperCamelCase				      =  CpmAntTokenizer.from_pretrained(lowercase			)
    __UpperCamelCase				      =  tokenizer(lowercase		,	return_tensors="""pt"""			)
    __UpperCamelCase				      =  model(**lowercase			).last_hidden_state
  
    __UpperCamelCase				      =  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        UpperCAmelCase__  (    unittest.TestCase):
  
  
  
   @tooslow
   def    __lowerCamelCase				(  self			)  ->							Any:
    __UpperCamelCase				      =  """今天天气真好！"""
    __UpperCamelCase				      =  """openbmb/cpm-ant-10b"""
    __UpperCamelCase				      =  CpmAntForCausalLM.from_pretrained(lowercase			)
    __UpperCamelCase				      =  CpmAntTokenizer.from_pretrained(lowercase			)
    __UpperCamelCase				      =  tokenizer(lowercase		,	return_tensors="""pt"""			)
    __UpperCamelCase				      =  model(**lowercase			).logits
  
    __UpperCamelCase				      =  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    __lowerCamelCase				(  self			)  ->							int:
    __UpperCamelCase				      =  """openbmb/cpm-ant-10b"""
    __UpperCamelCase				      =  CpmAntForCausalLM.from_pretrained(lowercase			)
    __UpperCamelCase				      =  CpmAntTokenizer.from_pretrained(lowercase			)
    __UpperCamelCase				      =  """今天天气不错，"""
    __UpperCamelCase				      =  """今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的"""
    __UpperCamelCase				      =  tokenizer(lowercase		,	return_tensors="""pt"""			)
    __UpperCamelCase				      =  model.generate(**lowercase			)
    __UpperCamelCase				      =  tokenizer.batch_decode(lowercase			)
    self.assertEqual(lowercase		,	lowercase			)
  
  
  
  
   @tooslow
   def    __lowerCamelCase				(  self			)  ->							Dict:
    __UpperCamelCase				      =  """openbmb/cpm-ant-10b"""
    __UpperCamelCase				      =  CpmAntForCausalLM.from_pretrained(lowercase			)
    __UpperCamelCase				      =  CpmAntTokenizer.from_pretrained(lowercase			)
    __UpperCamelCase				      =  ["""今天天气不错，""", """新年快乐，万事如意！"""]
    __UpperCamelCase				      =  [
        """今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的""",
        """新年快乐，万事如意！在这辞旧迎新的美好时刻，我谨代表《农村新技术》杂志社全体同仁，向一直以来关心、支持《农村新技术》杂志发展的各级领导、各界朋友和广大读者致以最诚挚的""",
    ]
    __UpperCamelCase				      =  tokenizer(lowercase		,	return_tensors="""pt"""		,	padding=lowercase			)
    __UpperCamelCase				      =  model.generate(**lowercase			)
    __UpperCamelCase				      =  tokenizer.batch_decode(lowercase			)
    self.assertEqual(lowercase		,	lowercase			)
  
  
  
  
  
  
style_context: 
  
  
  
  '''simple docstring'''
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_torch_available,
  )
  
  
  a__						:			Optional[int]										=			{
      'configuration_bark': [
          'BARK_PRETRAINED_CONFIG_ARCHIVE_MAP',
          'BarkCoarseConfig',
          'BarkConfig',
          'BarkFineConfig',
          'BarkSemanticConfig',
      ],
      'processing_bark': ['BarkProcessor'],
  }
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   a__						:			Any										=			[
       'BARK_PRETRAINED_MODEL_ARCHIVE_LIST',
       'BarkFineModel',
       'BarkSemanticModel',
       'BarkCoarseModel',
       'BarkModel',
       'BarkPreTrainedModel',
       'BarkCausalModel',
   ]
  
  if TYPE_CHECKING:
   from .configuration_bark import (
       BARK_PRETRAINED_CONFIG_ARCHIVE_MAP,
       BarkCoarseConfig,
       BarkConfig,
       BarkFineConfig,
       BarkSemanticConfig,
   )
   from .processing_bark import BarkProcessor
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_bark import (
        BARK_PRETRAINED_MODEL_ARCHIVE_LIST,
        BarkCausalModel,
        BarkCoarseModel,
        BarkFineModel,
        BarkModel,
        BarkPreTrainedModel,
        BarkSemanticModel,
    )
  
  else:
   import sys
  
   a__						:			Tuple										=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
  
  
  
  
  
  