





import argparse
import json
import os
import re
from collections import OrderedDict
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from pprint import pprint
from typing import Dict, List, Tuple

import torch
import torch.nn as nn
from classy_vision.models.regnet import RegNet, RegNetParams
from huggingface_hub import cached_download, hf_hub_url
from torch import Tensor
from vissl.models.model_helpers import get_trunk_forward_outputs

from transformers import AutoImageProcessor, RegNetConfig, RegNetForImageClassification, RegNetModel
from transformers.modeling_utils import PreTrainedModel
from transformers.utils import logging


logging.set_verbosity_info()
_UpperCAmelCase										=					logging.get_logger()



@dataclass
class 				_UpperCamelCase       :
       _UpperCamelCase					:       nn.Module
       _UpperCamelCase					:       List[nn.Module]       = field(default_factory=lowerCAmelCase_  )
       _UpperCamelCase					:       list       = field(default_factory=lowerCAmelCase_  )
       _UpperCamelCase					:       Dict[str, nn.Module]       = field(default_factory=lowerCAmelCase_  )

       def lowercase			(		self:			Optional[Any]       , _SCREAMING_SNAKE_CASE:			Optional[Any]       , _SCREAMING_SNAKE_CASE:			Tensor       , _SCREAMING_SNAKE_CASE:			Tensor       , _SCREAMING_SNAKE_CASE:			str		)							->			Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_ 							=	len(list(m.modules()		)		) == 1 or isinstance(_SCREAMING_SNAKE_CASE       , nn.Convad		) or isinstance(_SCREAMING_SNAKE_CASE       , nn.BatchNormad		)
              if has_not_submodules:
                     self.traced.append(_SCREAMING_SNAKE_CASE		)
                     UpperCamelCase_ 							=	m

       def __call__(		self:			List[str]       , _SCREAMING_SNAKE_CASE:			Tensor		)							->			Optional[Any]:




              """simple docstring"""


              for name, m in self.module.named_modules():
                     self.handles.append(m.register_forward_hook(partial(self._forward_hook       , name=_SCREAMING_SNAKE_CASE		)		)		)
              self.module(_SCREAMING_SNAKE_CASE		)
              [x.remove() for x in self.handles]
              return self



       @property
       def lowercase			(		self:			Dict		)							->			Dict:




              """simple docstring"""


              return {k: v for k, v in self.nameamodule.items() if len(list(v.state_dict().keys()		)		) > 0}



class 				_UpperCamelCase       (						nn.Module  ):

       def __init__(		self:			Optional[int]       , _SCREAMING_SNAKE_CASE:			nn.Module		)							->			int:




              """simple docstring"""


              super().__init__()

              UpperCamelCase_ 							=	[]
              # - get the stem
              feature_blocks.append(("conv1", model.stem)		)
              # - get all the feature blocks
              for k, v in model.trunk_output.named_children():
                     assert k.startswith("block"		), f'''Unexpected layer name {k}'''
                     UpperCamelCase_ 							=	len(_SCREAMING_SNAKE_CASE		) + 1
                     feature_blocks.append((f'''res{block_index}''', v)		)

              UpperCamelCase_ 							=	nn.ModuleDict(_SCREAMING_SNAKE_CASE		)



       def lowercase			(		self:			Any       , _SCREAMING_SNAKE_CASE:			Tensor		)							->			List[str]:




              """simple docstring"""


              return get_trunk_forward_outputs(
                  _SCREAMING_SNAKE_CASE       , out_feat_keys=_SCREAMING_SNAKE_CASE       , feature_blocks=self._feature_blocks       , )



class 				_UpperCamelCase       (						lowerCAmelCase_  ):

       def lowercase			(		self:			Dict		)							->			int:




              """simple docstring"""


              return [(8, 2, 2, 8, 1.0), (8, 2, 7, 8, 1.0), (8, 2, 17, 8, 1.0), (8, 2, 1, 8, 1.0)]




def 			lowerCAmelCase_			(				UpperCamelCase_	)  ->		Dict[str, str]:
       UpperCamelCase_ 							=	RegNetConfig(depths=[2, 7, 17, 1]       ,		hidden_sizes=[8, 8, 8, 8]       ,		groups_width=8	)
       if "in1k" in model_name:
              UpperCamelCase_ 							=	RegNetForImageClassification(UpperCamelCase_	)
       else:
              UpperCamelCase_ 							=	RegNetModel(UpperCamelCase_	)
       # create from model (with small weights)
       UpperCamelCase_ 							=	FakeRegNetVisslWrapper(
           RegNet(FakeRegNetParams(depth=27       ,		group_width=1010       ,		w_a=1744       ,		w_a=6_20.83       ,		w_m=2.52	)	)	)

       with torch.no_grad():
              UpperCamelCase_ 							=	from_model.eval()
              UpperCamelCase_ 							=	our_model.eval()

              UpperCamelCase_ 							=	torch.randn((1, 3, 32, 32)	)
              # trace both
              UpperCamelCase_ 							=	Tracker(UpperCamelCase_	)
              UpperCamelCase_ 							=	dest_tracker(UpperCamelCase_	).parametrized

              pprint(dest_tracker.nameamodule	)
              UpperCamelCase_ 							=	Tracker(UpperCamelCase_	)
              UpperCamelCase_ 							=	src_tracker(UpperCamelCase_	).parametrized

       # convert the keys -> module dict to keys -> params
       def to_params_dict(UpperCamelCase_	):
              UpperCamelCase_ 							=	OrderedDict()
              for name, module in dict_with_modules.items():
                     for param_name, param in module.state_dict().items():
                            UpperCamelCase_ 							=	param
              return params_dict

       UpperCamelCase_ 							=	{}

       UpperCamelCase_ 							=	to_params_dict(UpperCamelCase_	)
       UpperCamelCase_ 							=	to_params_dict(UpperCamelCase_	)

       for (src_key, src_param), (dest_key, dest_param) in zip(src_state_dict.items()       ,		dst_state_dict.items()	):
              UpperCamelCase_ 							=	dest_key
              logger.info(F'''{src_key} -> {dest_key}'''	)
       # if "in1k" was in the model_name it means it must have a classification head (was finetuned)
       if "in1k" in model_name:
              UpperCamelCase_ 							=	"classifier.1.weight"
              UpperCamelCase_ 							=	"classifier.1.bias"

       return from_to_ours_keys




def 			lowerCAmelCase_			(				UpperCamelCase_       ,		UpperCamelCase_ = None       ,		UpperCamelCase_ = True	)  ->		Dict:
       UpperCamelCase_ 							=	"imagenet-1k-id2label.json"
       UpperCamelCase_ 							=	1000

       UpperCamelCase_ 							=	"huggingface/label-files"
       UpperCamelCase_ 							=	num_labels
       UpperCamelCase_ 							=	json.load(open(cached_download(hf_hub_url(UpperCamelCase_       ,		UpperCamelCase_       ,		repo_type="dataset"	)	)       ,		"r"	)	)
       UpperCamelCase_ 							=	{int(UpperCamelCase_	): v for k, v in idalabel.items()}

       UpperCamelCase_ 							=	idalabel
       UpperCamelCase_ 							=	{v: k for k, v in idalabel.items()}

       UpperCamelCase_ 							=	partial(UpperCamelCase_       ,		num_labels=UpperCamelCase_       ,		idalabel=UpperCamelCase_       ,		labelaid=UpperCamelCase_	)

       UpperCamelCase_ 							=	{
           "regnet-y-10b-seer": ImageNetPreTrainedConfig(
               depths=[2, 7, 17, 1]       ,		hidden_sizes=[2020, 4040, 11110, 28280]       ,		groups_width=1010	),
           # finetuned on imagenet
           "regnet-y-10b-seer-in1k": ImageNetPreTrainedConfig(
               depths=[2, 7, 17, 1]       ,		hidden_sizes=[2020, 4040, 11110, 28280]       ,		groups_width=1010	),
       }

       # add seer weights logic
       def load_using_classy_vision(UpperCamelCase_	) -> Tuple[Dict, Dict]:
              UpperCamelCase_ 							=	torch.hub.load_state_dict_from_url(UpperCamelCase_       ,		model_dir=str(UpperCamelCase_	)       ,		map_location="cpu"	)
              # check if we have a head, if yes add it
              UpperCamelCase_ 							=	files["classy_state_dict"]["base_model"]["model"]
              return model_state_dict["trunk"], model_state_dict["heads"]

       UpperCamelCase_ 							=	{
           "regnet-y-10b-seer": partial(
               UpperCamelCase_       ,		"https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet10B/model_iteration124500_conso.torch"       ,		),
           "regnet-y-10b-seer-in1k": partial(
               UpperCamelCase_       ,		"https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_10b_finetuned_in1k_model_phase28_conso.torch"       ,		),
       }

       UpperCamelCase_ 							=	get_from_to_our_keys(UpperCamelCase_	)

       if not (save_directory / F'''{model_name}.pth''').exists():
              logger.info("Loading original state_dict."	)
              UpperCamelCase_							,			UpperCamelCase_ 							=	names_to_from_model[model_name]()
              UpperCamelCase_ 							=	from_state_dict_trunk
              if "in1k" in model_name:
                     # add the head
                     UpperCamelCase_ 							=	{**from_state_dict_trunk, **from_state_dict_head}
              logger.info("Done!"	)

              UpperCamelCase_ 							=	{}

              UpperCamelCase_ 							=	list(from_state_dict.keys()	)
              UpperCamelCase_ 							=	r"\.block.-part."
              # this is "interesting", so the original checkpoints have `block[0,1]-part` in each key name, we remove it
              for key in from_state_dict.keys():
                     # remove the weird "block[0,1]-part" from the key
                     UpperCamelCase_ 							=	re.sub(UpperCamelCase_       ,		""       ,		UpperCamelCase_	)
                     # now src_key from the model checkpoints is the one we got from the original model after tracing, so use it to get the correct destination key
                     UpperCamelCase_ 							=	from_to_ours_keys[src_key]
                     # store the parameter with our key
                     UpperCamelCase_ 							=	from_state_dict[key]
                     not_used_keys.remove(UpperCamelCase_	)
              # check that all keys have been updated
              assert len(UpperCamelCase_	) == 0, F'''Some keys where not used {",".join(UpperCamelCase_	)}'''

              logger.info(F'''The following keys were not used: {",".join(UpperCamelCase_	)}'''	)

              # save our state dict to disk
              torch.save(UpperCamelCase_       ,		save_directory / F'''{model_name}.pth'''	)

              del converted_state_dict
       else:
              logger.info("The state_dict was already stored on disk."	)
       if push_to_hub:
              logger.info(F'''Token is {os.environ["HF_TOKEN"]}'''	)
              logger.info("Loading our model."	)
              # create our model
              UpperCamelCase_ 							=	names_to_config[model_name]
              UpperCamelCase_ 							=	RegNetModel
              if "in1k" in model_name:
                     UpperCamelCase_ 							=	RegNetForImageClassification
              UpperCamelCase_ 							=	our_model_func(UpperCamelCase_	)
              # place our model to the meta device (so remove all the weights)
              our_model.to(torch.device("meta"	)	)
              logger.info("Loading state_dict in our model."	)
              # load state dict
              UpperCamelCase_ 							=	our_model.state_dict().keys()
              PreTrainedModel._load_pretrained_model_low_mem(
                  UpperCamelCase_       ,		UpperCamelCase_       ,		[save_directory / F'''{model_name}.pth''']	)
              logger.info("Finally, pushing!"	)
              # push it to hub
              our_model.push_to_hub(
                  repo_path_or_name=save_directory / model_name       ,		commit_message="Add model"       ,		output_dir=save_directory / model_name       ,		)
              UpperCamelCase_ 							=	384
              # we can use the convnext one
              UpperCamelCase_ 							=	AutoImageProcessor.from_pretrained("facebook/convnext-base-224-22k-1k"       ,		size=UpperCamelCase_	)
              image_processor.push_to_hub(
                  repo_path_or_name=save_directory / model_name       ,		commit_message="Add image processor"       ,		output_dir=save_directory / model_name       ,		)


if __name__ == "__main__":
     _UpperCAmelCase										=					argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '--model_name',
         default=None,
         type=str,
         help=(
             'The name of the model you wish to convert, it must be one of the supported regnet* architecture,'
             ' currently: regnetx-*, regnety-*. If `None`, all of them will the converted.'
         ),
     )
     parser.add_argument(
         '--pytorch_dump_folder_path',
         default=None,
         type=Path,
         required=True,
         help='Path to the output PyTorch model directory.',
     )
     parser.add_argument(
         '--push_to_hub',
         default=True,
         type=bool,
         required=False,
         help='If True, push model and image processor to the hub.',
     )

     _UpperCAmelCase										=					parser.parse_args()

     _UpperCAmelCase										=					args.pytorch_dump_folder_path
     pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
     convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)








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:			Optional[Any]       , _SCREAMING_SNAKE_CASE:			Any       , _SCREAMING_SNAKE_CASE:			List[Any]=2       , _SCREAMING_SNAKE_CASE:			List[str]=8       , _SCREAMING_SNAKE_CASE:			Optional[Any]=True       , _SCREAMING_SNAKE_CASE:			List[str]=False       , _SCREAMING_SNAKE_CASE:			int=False       , _SCREAMING_SNAKE_CASE:			Optional[Any]=False       , _SCREAMING_SNAKE_CASE:			List[str]=False       , _SCREAMING_SNAKE_CASE:			List[Any]=99       , _SCREAMING_SNAKE_CASE:			str=32       , _SCREAMING_SNAKE_CASE:			Tuple=3       , _SCREAMING_SNAKE_CASE:			Union[str, Any]=4       , _SCREAMING_SNAKE_CASE:			List[Any]=37       , _SCREAMING_SNAKE_CASE:			int=32       , _SCREAMING_SNAKE_CASE:			int=128       , _SCREAMING_SNAKE_CASE:			Dict=8       , _SCREAMING_SNAKE_CASE:			Optional[Any]=8       , _SCREAMING_SNAKE_CASE:			str=8       , _SCREAMING_SNAKE_CASE:			Dict=1.0       , _SCREAMING_SNAKE_CASE:			List[str]=True       , )							->			Optional[int]:




              """simple docstring"""


              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 lowercase			(		self:			Dict		)							->			str:




              """simple docstring"""


              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 lowercase			(		self:			Union[str, Any]		)							->			List[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=_SCREAMING_SNAKE_CASE       , init_std=self.init_std       , return_dict=self.return_dict       , )

       def lowercase			(		self:			Dict       , _SCREAMING_SNAKE_CASE:			Union[str, Any]       , _SCREAMING_SNAKE_CASE:			List[str]       , *_SCREAMING_SNAKE_CASE:			Tuple		)							->			str:




              """simple docstring"""


              UpperCamelCase_ 							=	CpmAntModel(config=_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              model.eval()

              UpperCamelCase_ 							=	model(**_SCREAMING_SNAKE_CASE		).last_hidden_state

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

       def lowercase			(		self:			Optional[Any]       , _SCREAMING_SNAKE_CASE:			Tuple       , _SCREAMING_SNAKE_CASE:			Optional[Any]       , *_SCREAMING_SNAKE_CASE:			Dict		)							->			Optional[int]:




              """simple docstring"""


              UpperCamelCase_ 							=	CpmAntForCausalLM(_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	input_ids["input_ids"].to(_SCREAMING_SNAKE_CASE		)
              model.eval()

              UpperCamelCase_ 							=	model(**_SCREAMING_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 lowercase			(		self:			Any		)							->			Dict:




              """simple docstring"""


              UpperCamelCase_							,			UpperCamelCase_ 							=	self.prepare_config_and_inputs()
              return config, inputs_dict



@require_torch
class 				_UpperCamelCase       (						lowerCAmelCase_	,    lowerCAmelCase_	,    unittest.TestCase  ):
       _UpperCamelCase					:       Dict       = (CpmAntModel, CpmAntForCausalLM) if is_torch_available() else ()
       _UpperCamelCase					:       Union[str, Any]       = (
           {'''feature-extraction''': CpmAntModel, '''text-generation''': CpmAntForCausalLM} if is_torch_available() else {}
       )

       _UpperCamelCase					:       Optional[Any]       = False
       _UpperCamelCase					:       Dict       = False
       _UpperCamelCase					:       Any       = False
       _UpperCamelCase					:       Optional[Any]       = False
       _UpperCamelCase					:       Any       = False

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




              """simple docstring"""


              UpperCamelCase_ 							=	CpmAntModelTester(self		)
              UpperCamelCase_ 							=	ConfigTester(self       , config_class=_SCREAMING_SNAKE_CASE		)

       def lowercase			(		self:			str		)							->			Any:




              """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 lowercase			(		self:			Any		)							->			List[str]:




              """simple docstring"""


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

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




              """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 lowercase			(		self:			List[str]		)							->			Optional[Any]:




              """simple docstring"""


              UpperCamelCase_							,			UpperCamelCase_ 							=	self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_cpmant_model(_SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE		)



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




              """simple docstring"""


              UpperCamelCase_							,			UpperCamelCase_ 							=	self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_lm_head_model(_SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE		)



@require_torch
class 				_UpperCamelCase       (						unittest.TestCase  ):

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




              """simple docstring"""


              UpperCamelCase_ 							=	"今天天气真好！"
              UpperCamelCase_ 							=	"openbmb/cpm-ant-10b"
              UpperCamelCase_ 							=	CpmAntModel.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	CpmAntTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	tokenizer(_SCREAMING_SNAKE_CASE       , return_tensors="pt"		)
              UpperCamelCase_ 							=	model(**_SCREAMING_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]       , _SCREAMING_SNAKE_CASE       , atol=1e-2		)		)



@require_torch
class 				_UpperCamelCase       (						unittest.TestCase  ):

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




              """simple docstring"""


              UpperCamelCase_ 							=	"今天天气真好！"
              UpperCamelCase_ 							=	"openbmb/cpm-ant-10b"
              UpperCamelCase_ 							=	CpmAntForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	CpmAntTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	tokenizer(_SCREAMING_SNAKE_CASE       , return_tensors="pt"		)
              UpperCamelCase_ 							=	model(**_SCREAMING_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]       , _SCREAMING_SNAKE_CASE       , atol=1e-2		)		)

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




              """simple docstring"""


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



       @tooslow
       def lowercase			(		self:			List[str]		)							->			Optional[Any]:




              """simple docstring"""


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

