




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


a_										=       {
    "configuration_sam": [
        "SAM_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "SamConfig",
        "SamMaskDecoderConfig",
        "SamPromptEncoderConfig",
        "SamVisionConfig",
    ],
    "processing_sam": ["SamProcessor"],
}


try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a_										=       [
     "SAM_PRETRAINED_MODEL_ARCHIVE_LIST",
     "SamModel",
     "SamPreTrainedModel",
 ]
try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a_										=       [
     "TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST",
     "TFSamModel",
     "TFSamPreTrainedModel",
 ]
try:
 if not is_vision_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a_										=       ["SamImageProcessor"]


if TYPE_CHECKING:
 from .configuration_sam import (
     SAM_PRETRAINED_CONFIG_ARCHIVE_MAP,
     SamConfig,
     SamMaskDecoderConfig,
     SamPromptEncoderConfig,
     SamVisionConfig,
 )
 from .processing_sam import SamProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_sam import SAM_PRETRAINED_MODEL_ARCHIVE_LIST, SamModel, SamPreTrainedModel

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_sam import TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST, TFSamModel, TFSamPreTrainedModel

 try:
  if not is_vision_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .image_processing_sam import SamImageProcessor

else:
 import sys

 a_										=       _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)












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  :

      """simple docstring"""

      def __init__(       self   :	str	,    snake_case   :	str	,    snake_case   :	List[str]=2	,    snake_case   :	Optional[Any]=8	,    snake_case   :	List[Any]=True	,    snake_case   :	Optional[Any]=False	,    snake_case   :	str=False	,    snake_case   :	Tuple=False	,    snake_case   :	str=False	,    snake_case   :	int=99	,    snake_case   :	Tuple=32	,    snake_case   :	Union[str, Any]=3	,    snake_case   :	str=4	,    snake_case   :	List[Any]=37	,    snake_case   :	Tuple=32	,    snake_case   :	Tuple=128	,    snake_case   :	Optional[int]=8	,    snake_case   :	Optional[Any]=8	,    snake_case   :	List[Any]=8	,    snake_case   :	List[str]=1.0	,    snake_case   :	List[Any]=True	,    ):
          __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  snake_case		(       self   :	Tuple			):
          __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  snake_case		(       self   :	List[str]			):
          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=snake_case	,    init_std=self.init_std	,    return_dict=self.return_dict	,    )







      def  snake_case		(       self   :	Union[str, Any]	,    snake_case   :	Tuple	,    snake_case   :	List[str]	,    *snake_case   :	str			):
          __UpperCamelCase											=  CpmAntModel(config=snake_case			)
          model.to(snake_case			)
          model.eval()

          __UpperCamelCase											=  model(**snake_case			).last_hidden_state

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







      def  snake_case		(       self   :	List[str]	,    snake_case   :	Optional[int]	,    snake_case   :	List[str]	,    *snake_case   :	Any			):
          __UpperCamelCase											=  CpmAntForCausalLM(snake_case			)
          model.to(snake_case			)
          __UpperCamelCase											=  input_ids['''input_ids'''].to(snake_case			)
          model.eval()

          __UpperCamelCase											=  model(**snake_case			)
          self.parent.assertEqual(
              model_output.logits.shape	,    (self.batch_size, self.seq_length, config.vocab_size + config.prompt_types * config.prompt_length)	,    )







      def  snake_case		(       self   :	List[str]			):
          __UpperCamelCase						, __UpperCamelCase											=  self.prepare_config_and_inputs()
          return config, inputs_dict







@require_torch
class 	_lowerCamelCase  (     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     unittest.TestCase				):

      """simple docstring"""

      lowerCAmelCase__     :	List[Any]      =   (CpmAntModel, CpmAntForCausalLM) if is_torch_available() else ()
      lowerCAmelCase__     :	Union[str, Any]      =   (
          {"feature-extraction": CpmAntModel, "text-generation": CpmAntForCausalLM} if is_torch_available() else {}
      )

      lowerCAmelCase__     :	Optional[int]      =   False
      lowerCAmelCase__     :	Union[str, Any]      =   False
      lowerCAmelCase__     :	Optional[int]      =   False
      lowerCAmelCase__     :	Tuple      =   False
      lowerCAmelCase__     :	Union[str, Any]      =   False







      def  snake_case		(       self   :	Any			):
          __UpperCamelCase											=  CpmAntModelTester(self			)
          __UpperCamelCase											=  ConfigTester(self	,    config_class=snake_case			)







      def  snake_case		(       self   :	Optional[Any]			):
          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  snake_case		(       self   :	List[str]			):
          unittest.skip('''CPMAnt doesn\'t support input_embeds.'''			)(self.test_inputs_embeds			)







      def  snake_case		(       self   :	int			):
          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  snake_case		(       self   :	Union[str, Any]			):
          __UpperCamelCase						, __UpperCamelCase											=  self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_cpmant_model(snake_case	,    snake_case			)







      def  snake_case		(       self   :	Any			):
          __UpperCamelCase						, __UpperCamelCase											=  self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_lm_head_model(snake_case	,    snake_case			)







@require_torch
class 	_lowerCamelCase  (     unittest.TestCase				):

      """simple docstring"""

      @tooslow
      def  snake_case		(       self   :	Dict			):
          __UpperCamelCase											=  '''今天天气真好！'''
          __UpperCamelCase											=  '''openbmb/cpm-ant-10b'''
          __UpperCamelCase											=  CpmAntModel.from_pretrained(snake_case			)
          __UpperCamelCase											=  CpmAntTokenizer.from_pretrained(snake_case			)
          __UpperCamelCase											=  tokenizer(snake_case	,    return_tensors='''pt'''			)
          __UpperCamelCase											=  model(**snake_case			).last_hidden_state

          __UpperCamelCase											=  torch.tensor(
              [[[6.17_08, 5.92_44, 1.08_35], [6.52_07, 6.28_93, -11.33_24], [-1.01_07, -0.05_76, -5.95_77]]]	,    )
          self.assertTrue(torch.allclose(hidden_states[:, :3, :3]	,    snake_case	,    atol=1E-2			)			)







@require_torch
class 	_lowerCamelCase  (     unittest.TestCase				):

      """simple docstring"""

      @tooslow
      def  snake_case		(       self   :	Optional[int]			):
          __UpperCamelCase											=  '''今天天气真好！'''
          __UpperCamelCase											=  '''openbmb/cpm-ant-10b'''
          __UpperCamelCase											=  CpmAntForCausalLM.from_pretrained(snake_case			)
          __UpperCamelCase											=  CpmAntTokenizer.from_pretrained(snake_case			)
          __UpperCamelCase											=  tokenizer(snake_case	,    return_tensors='''pt'''			)
          __UpperCamelCase											=  model(**snake_case			).logits

          __UpperCamelCase											=  torch.tensor(
              [[[-6.42_67, -6.40_83, -6.39_58], [-5.88_02, -5.94_47, -5.78_11], [-5.38_96, -5.48_20, -5.42_95]]]	,    )
          self.assertTrue(torch.allclose(hidden_states[:, :3, :3]	,    snake_case	,    atol=1E-2			)			)







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







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






