




"""simple docstring"""





import argparse
import json
from collections import OrderedDict
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    SegformerConfig,
    SegformerForImageClassification,
    SegformerForSemanticSegmentation,
    SegformerImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
A   =       logging.get_logger(__name__)

def 					_UpperCamelCase    (			UpperCamelCase				,       UpperCamelCase=False							)			->			int:


			"""simple docstring"""
			__UpperCAmelCase	: Optional[Any]		=					OrderedDict()
			for key, value in state_dict.items():
						if encoder_only and not key.startswith("head"							):
									__UpperCAmelCase	: Dict		=					"segformer.encoder." + key
						if key.startswith("backbone"							):
									__UpperCAmelCase	: Dict		=					key.replace("backbone"				,       "segformer.encoder"							)
						if "patch_embed" in key:
									# replace for example patch_embed1 by patch_embeddings.0
									__UpperCAmelCase	: int		=					key[key.find("patch_embed"							) + len("patch_embed"							)]
									__UpperCAmelCase	: List[Any]		=					key.replace(f"patch_embed{idx}"				,       f"patch_embeddings.{int(UpperCamelCase							)-1}"							)
						if "norm" in key:
									__UpperCAmelCase	: Dict		=					key.replace("norm"				,       "layer_norm"							)
						if "segformer.encoder.layer_norm" in key:
									# replace for example layer_norm1 by layer_norm.0
									__UpperCAmelCase	: Tuple		=					key[key.find("segformer.encoder.layer_norm"							) + len("segformer.encoder.layer_norm"							)]
									__UpperCAmelCase	: Any		=					key.replace(f"layer_norm{idx}"				,       f"layer_norm.{int(UpperCamelCase							)-1}"							)
						if "layer_norm1" in key:
									__UpperCAmelCase	: Optional[int]		=					key.replace("layer_norm1"				,       "layer_norm_1"							)
						if "layer_norm2" in key:
									__UpperCAmelCase	: Any		=					key.replace("layer_norm2"				,       "layer_norm_2"							)
						if "block" in key:
									# replace for example block1 by block.0
									__UpperCAmelCase	: List[str]		=					key[key.find("block"							) + len("block"							)]
									__UpperCAmelCase	: Union[str, Any]		=					key.replace(f"block{idx}"				,       f"block.{int(UpperCamelCase							)-1}"							)
						if "attn.q" in key:
									__UpperCAmelCase	: int		=					key.replace("attn.q"				,       "attention.self.query"							)
						if "attn.proj" in key:
									__UpperCAmelCase	: str		=					key.replace("attn.proj"				,       "attention.output.dense"							)
						if "attn" in key:
									__UpperCAmelCase	: Optional[int]		=					key.replace("attn"				,       "attention.self"							)
						if "fc1" in key:
									__UpperCAmelCase	: List[Any]		=					key.replace("fc1"				,       "dense1"							)
						if "fc2" in key:
									__UpperCAmelCase	: int		=					key.replace("fc2"				,       "dense2"							)
						if "linear_pred" in key:
									__UpperCAmelCase	: str		=					key.replace("linear_pred"				,       "classifier"							)
						if "linear_fuse" in key:
									__UpperCAmelCase	: Optional[int]		=					key.replace("linear_fuse.conv"				,       "linear_fuse"							)
									__UpperCAmelCase	: List[Any]		=					key.replace("linear_fuse.bn"				,       "batch_norm"							)
						if "linear_c" in key:
									# replace for example linear_c4 by linear_c.3
									__UpperCAmelCase	: Any		=					key[key.find("linear_c"							) + len("linear_c"							)]
									__UpperCAmelCase	: Dict		=					key.replace(f"linear_c{idx}"				,       f"linear_c.{int(UpperCamelCase							)-1}"							)
						if key.startswith("head"							):
									__UpperCAmelCase	: str		=					key.replace("head"				,       "classifier"							)
						__UpperCAmelCase	: Union[str, Any]		=					value

			return new_state_dict

def 					_UpperCamelCase    (			UpperCamelCase				,       UpperCamelCase							)			->			List[Any]:


			"""simple docstring"""
			# for each of the encoder blocks:
			for i in range(config.num_encoder_blocks							):
						for j in range(config.depths[i]							):
									# read in weights + bias of keys and values (which is a single matrix in the original implementation)
									__UpperCAmelCase	: List[Any]		=					state_dict.pop(f"segformer.encoder.block.{i}.{j}.attention.self.kv.weight"							)
									__UpperCAmelCase	: Any		=					state_dict.pop(f"segformer.encoder.block.{i}.{j}.attention.self.kv.bias"							)
									# next, add keys and values (in that order) to the state dict
									__UpperCAmelCase	: Tuple		=					kv_weight[
									    : config.hidden_sizes[i], :
									]
									__UpperCAmelCase	: int		=					kv_bias[: config.hidden_sizes[i]]
									__UpperCAmelCase	: Tuple		=					kv_weight[
									    config.hidden_sizes[i] :, :
									]
									__UpperCAmelCase	: Dict		=					kv_bias[
									    config.hidden_sizes[i] :
									]

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


			"""simple docstring"""
			__UpperCAmelCase	: str		=					"http://images.cocodataset.org/val2017/000000039769.jpg"
			__UpperCAmelCase	: Optional[Any]		=					Image.open(requests.get(UpperCamelCase				,       stream=UpperCamelCase							).raw							)

			return image

@torch.no_grad()
def 					_UpperCamelCase    (			UpperCamelCase				,       UpperCamelCase				,       UpperCamelCase							)			->			Optional[int]:


			"""simple docstring"""
			__UpperCAmelCase	: List[Any]		=					SegformerConfig()
			__UpperCAmelCase	: int		=					False

			# set attributes based on model_name
			__UpperCAmelCase	: Optional[Any]		=					"huggingface/label-files"
			if "segformer" in model_name:
						__UpperCAmelCase	: Optional[int]		=					model_name[len("segformer."							) : len("segformer."							) + 2]
						if "ade" in model_name:
									__UpperCAmelCase	: List[str]		=					150
									__UpperCAmelCase	: str		=					"ade20k-id2label.json"
									__UpperCAmelCase	: Dict		=					(1, 150, 128, 128)
						elif "city" in model_name:
									__UpperCAmelCase	: Tuple		=					19
									__UpperCAmelCase	: str		=					"cityscapes-id2label.json"
									__UpperCAmelCase	: Union[str, Any]		=					(1, 19, 128, 128)
						else:
									raise ValueError(f"Model {model_name} not supported"							)
			elif "mit" in model_name:
						__UpperCAmelCase	: List[Any]		=					True
						__UpperCAmelCase	: List[str]		=					model_name[4:6]
						__UpperCAmelCase	: int		=					1000
						__UpperCAmelCase	: Optional[Any]		=					"imagenet-1k-id2label.json"
						__UpperCAmelCase	: Tuple		=					(1, 1000)
			else:
						raise ValueError(f"Model {model_name} not supported"							)

			# set config attributes
			__UpperCAmelCase	: List[Any]		=					json.load(open(hf_hub_download(UpperCamelCase				,       UpperCamelCase				,       repo_type="dataset"							)				,       "r"							)							)
			__UpperCAmelCase	: Tuple		=					{int(UpperCamelCase							): v for k, v in idalabel.items()}
			__UpperCAmelCase	: int		=					idalabel
			__UpperCAmelCase	: int		=					{v: k for k, v in idalabel.items()}
			if size == "b0":
						pass
			elif size == "b1":
						__UpperCAmelCase	: Optional[int]		=					[64, 128, 320, 512]
						__UpperCAmelCase	: List[str]		=					256
			elif size == "b2":
						__UpperCAmelCase	: str		=					[64, 128, 320, 512]
						__UpperCAmelCase	: Any		=					768
						__UpperCAmelCase	: Any		=					[3, 4, 6, 3]
			elif size == "b3":
						__UpperCAmelCase	: Any		=					[64, 128, 320, 512]
						__UpperCAmelCase	: str		=					768
						__UpperCAmelCase	: Union[str, Any]		=					[3, 4, 18, 3]
			elif size == "b4":
						__UpperCAmelCase	: int		=					[64, 128, 320, 512]
						__UpperCAmelCase	: List[Any]		=					768
						__UpperCAmelCase	: str		=					[3, 8, 27, 3]
			elif size == "b5":
						__UpperCAmelCase	: Tuple		=					[64, 128, 320, 512]
						__UpperCAmelCase	: int		=					768
						__UpperCAmelCase	: Dict		=					[3, 6, 40, 3]
			else:
						raise ValueError(f"Size {size} not supported"							)

			# load image processor (only resize + normalize)
			__UpperCAmelCase	: List[Any]		=					SegformerImageProcessor(
			    image_scale=(512, 512)				,       keep_ratio=UpperCamelCase				,       align=UpperCamelCase				,       do_random_crop=UpperCamelCase							)

			# prepare image
			__UpperCAmelCase	: Optional[Any]		=					prepare_img()
			__UpperCAmelCase	: List[str]		=					image_processor(images=UpperCamelCase				,       return_tensors="pt"							).pixel_values

			logger.info(f"Converting model {model_name}..."							)

			# load original state dict
			if encoder_only:
						__UpperCAmelCase	: Optional[Any]		=					torch.load(UpperCamelCase				,       map_location=torch.device("cpu"							)							)
			else:
						__UpperCAmelCase	: int		=					torch.load(UpperCamelCase				,       map_location=torch.device("cpu"							)							)["state_dict"]

			# rename keys
			__UpperCAmelCase	: Union[str, Any]		=					rename_keys(UpperCamelCase				,       encoder_only=UpperCamelCase							)
			if not encoder_only:
						del state_dict["decode_head.conv_seg.weight"]
						del state_dict["decode_head.conv_seg.bias"]

			# key and value matrices need special treatment
			read_in_k_v(UpperCamelCase				,       UpperCamelCase							)

			# create HuggingFace model and load state dict
			if encoder_only:
						__UpperCAmelCase	: str		=					False
						__UpperCAmelCase	: int		=					SegformerForImageClassification(UpperCamelCase							)
			else:
						__UpperCAmelCase	: List[str]		=					SegformerForSemanticSegmentation(UpperCamelCase							)
			model.load_state_dict(UpperCamelCase							)
			model.eval()

			# forward pass
			__UpperCAmelCase	: Union[str, Any]		=					model(UpperCamelCase							)
			__UpperCAmelCase	: Union[str, Any]		=					outputs.logits

			# set expected_slice based on model name
			# ADE20k checkpoints
			if model_name == "segformer.b0.512x512.ade.160k":
						__UpperCAmelCase	: List[str]		=					torch.tensor(
						    [
						        [[-4.6310, -5.5232, -6.2356], [-5.1921, -6.1444, -6.5996], [-5.4424, -6.2790, -6.7574]],
						        [[-12.1391, -13.3122, -13.9554], [-12.8732, -13.9352, -14.3563], [-12.9438, -13.8226, -14.2513]],
						        [[-12.5134, -13.4686, -14.4915], [-12.8669, -14.4343, -14.7758], [-13.2523, -14.5819, -15.0694]],
						    ]							)
			elif model_name == "segformer.b1.512x512.ade.160k":
						__UpperCAmelCase	: str		=					torch.tensor(
						    [
						        [[-7.5820, -8.7231, -8.3215], [-8.0600, -10.3529, -10.0304], [-7.5208, -9.4103, -9.6239]],
						        [[-12.6918, -13.8994, -13.7137], [-13.3196, -15.7523, -15.4789], [-12.9343, -14.8757, -14.9689]],
						        [[-11.1911, -11.9421, -11.3243], [-11.3342, -13.6839, -13.3581], [-10.3909, -12.1832, -12.4858]],
						    ]							)
			elif model_name == "segformer.b2.512x512.ade.160k":
						__UpperCAmelCase	: Any		=					torch.tensor(
						    [
						        [[-11.8173, -14.3850, -16.3128], [-14.5648, -16.5804, -18.6568], [-14.7223, -15.7387, -18.4218]],
						        [[-15.7290, -17.9171, -19.4423], [-18.3105, -19.9448, -21.4661], [-17.9296, -18.6497, -20.7910]],
						        [[-15.0783, -17.0336, -18.2789], [-16.8771, -18.6870, -20.1612], [-16.2454, -17.1426, -19.5055]],
						    ]							)
			elif model_name == "segformer.b3.512x512.ade.160k":
						__UpperCAmelCase	: int		=					torch.tensor(
						    [
						        [[-9.0878, -10.2081, -10.1891], [-9.3144, -10.7941, -10.9843], [-9.2294, -10.3855, -10.5704]],
						        [[-12.2316, -13.9068, -13.6102], [-12.9161, -14.3702, -14.3235], [-12.5233, -13.7174, -13.7932]],
						        [[-14.6275, -15.2490, -14.9727], [-14.3400, -15.9687, -16.2827], [-14.1484, -15.4033, -15.8937]],
						    ]							)
			elif model_name == "segformer.b4.512x512.ade.160k":
						__UpperCAmelCase	: List[str]		=					torch.tensor(
						    [
						        [[-12.3144, -13.2447, -14.0802], [-13.3614, -14.5816, -15.6117], [-13.3340, -14.4433, -16.2219]],
						        [[-19.2781, -20.4128, -20.7506], [-20.6153, -21.6566, -22.0998], [-19.9800, -21.0430, -22.1494]],
						        [[-18.8739, -19.7804, -21.1834], [-20.1233, -21.6765, -23.2944], [-20.0315, -21.2641, -23.6944]],
						    ]							)
			elif model_name == "segformer.b5.640x640.ade.160k":
						__UpperCAmelCase	: int		=					torch.tensor(
						    [
						        [[-9.5524, -12.0835, -11.7348], [-10.5229, -13.6446, -14.5662], [-9.5842, -12.8851, -13.9414]],
						        [[-15.3432, -17.5323, -17.0818], [-16.3330, -18.9255, -19.2101], [-15.1340, -17.7848, -18.3971]],
						        [[-12.6072, -14.9486, -14.6631], [-13.7629, -17.0907, -17.7745], [-12.7899, -16.1695, -17.1671]],
						    ]							)
			# Cityscapes checkpoints
			elif model_name == "segformer.b0.1024x1024.city.160k":
						__UpperCAmelCase	: int		=					torch.tensor(
						    [
						        [[-11.9295, -13.4057, -14.8106], [-13.3431, -14.8179, -15.3781], [-14.2836, -15.5942, -16.1588]],
						        [[-11.4906, -12.8067, -13.6564], [-13.1189, -14.0500, -14.1543], [-13.8748, -14.5136, -14.8789]],
						        [[0.5374, 0.1067, -0.4742], [0.1141, -0.2255, -0.7099], [-0.3000, -0.5924, -1.3105]],
						    ]							)
			elif model_name == "segformer.b0.512x1024.city.160k":
						__UpperCAmelCase	: Union[str, Any]		=					torch.tensor(
						    [
						        [[-7.8217, -9.8767, -10.1717], [-9.4438, -10.9058, -11.4047], [-9.7939, -12.3495, -12.1079]],
						        [[-7.1514, -9.5336, -10.0860], [-9.7776, -11.6822, -11.8439], [-10.1411, -12.7655, -12.8972]],
						        [[0.3021, 0.0805, -0.2310], [-0.0328, -0.1605, -0.2714], [-0.1408, -0.5477, -0.6976]],
						    ]							)
			elif model_name == "segformer.b0.640x1280.city.160k":
						__UpperCAmelCase	: int		=					torch.tensor(
						    [
						        [
						            [-1.1_3_7_2e0_1, -1.2_7_8_7e0_1, -1.3_4_7_7e0_1],
						            [-1.2_5_3_6e0_1, -1.4_1_9_4e0_1, -1.4_4_0_9e0_1],
						            [-1.3_2_1_7e0_1, -1.4_8_8_8e0_1, -1.5_3_2_7e0_1],
						        ],
						        [
						            [-1.4_7_9_1e0_1, -1.7_1_2_2e0_1, -1.8_2_7_7e0_1],
						            [-1.7_1_6_3e0_1, -1.9_1_9_2e0_1, -1.9_5_3_3e0_1],
						            [-1.7_8_9_7e0_1, -1.9_9_9_1e0_1, -2.0_3_1_5e0_1],
						        ],
						        [
						            [7.6_7_2_3e-0_1, 4.1_9_2_1e-0_1, -7.7_8_7_8e-0_2],
						            [4.7_7_7_2e-0_1, 9.5_5_5_7e-0_3, -2.8_0_8_2e-0_1],
						            [3.6_0_3_2e-0_1, -2.4_8_2_6e-0_1, -5.1_1_6_8e-0_1],
						        ],
						    ]							)
			elif model_name == "segformer.b0.768x768.city.160k":
						__UpperCAmelCase	: List[str]		=					torch.tensor(
						    [
						        [[-9.4959, -11.3087, -11.7479], [-11.0025, -12.6540, -12.3319], [-11.4064, -13.0487, -12.9905]],
						        [[-9.8905, -11.3084, -12.0854], [-11.1726, -12.7698, -12.9583], [-11.5985, -13.3278, -14.1774]],
						        [[0.2213, 0.0192, -0.2466], [-0.1731, -0.4213, -0.4874], [-0.3126, -0.6541, -1.1389]],
						    ]							)
			elif model_name == "segformer.b1.1024x1024.city.160k":
						__UpperCAmelCase	: List[Any]		=					torch.tensor(
						    [
						        [[-13.5748, -13.9111, -12.6500], [-14.3500, -15.3683, -14.2328], [-14.7532, -16.0424, -15.6087]],
						        [[-17.1651, -15.8725, -12.9653], [-17.2580, -17.3718, -14.8223], [-16.6058, -16.8783, -16.7452]],
						        [[-3.6456, -3.0209, -1.4203], [-3.0797, -3.1959, -2.0000], [-1.8757, -1.9217, -1.6997]],
						    ]							)
			elif model_name == "segformer.b2.1024x1024.city.160k":
						__UpperCAmelCase	: Tuple		=					torch.tensor(
						    [
						        [[-16.0976, -16.4856, -17.3962], [-16.6234, -19.0342, -19.7685], [-16.0900, -18.0661, -19.1180]],
						        [[-18.4750, -18.8488, -19.5074], [-19.4030, -22.1570, -22.5977], [-19.1191, -20.8486, -22.3783]],
						        [[-4.5178, -5.5037, -6.5109], [-5.0884, -7.2174, -8.0334], [-4.4156, -5.8117, -7.2970]],
						    ]							)
			elif model_name == "segformer.b3.1024x1024.city.160k":
						__UpperCAmelCase	: List[Any]		=					torch.tensor(
						    [
						        [[-14.2081, -14.4732, -14.1977], [-14.5867, -16.4423, -16.6356], [-13.4441, -14.9685, -16.8696]],
						        [[-14.4576, -14.7073, -15.0451], [-15.0816, -17.6237, -17.9873], [-14.4213, -16.0199, -18.5992]],
						        [[-4.7349, -4.9588, -5.0966], [-4.3210, -6.9325, -7.2591], [-3.4312, -4.7484, -7.1917]],
						    ]							)
			elif model_name == "segformer.b4.1024x1024.city.160k":
						__UpperCAmelCase	: Union[str, Any]		=					torch.tensor(
						    [
						        [[-11.7737, -11.9526, -11.3273], [-13.6692, -14.4574, -13.8878], [-13.8937, -14.6924, -15.9345]],
						        [[-14.6706, -14.5330, -14.1306], [-16.1502, -16.8180, -16.4269], [-16.8338, -17.8939, -20.1746]],
						        [[1.0491, 0.8289, 1.0310], [1.1044, 0.5219, 0.8055], [1.0899, 0.6926, 0.5590]],
						    ]							)
			elif model_name == "segformer.b5.1024x1024.city.160k":
						__UpperCAmelCase	: Union[str, Any]		=					torch.tensor(
						    [
						        [[-12.5641, -13.4777, -13.0684], [-13.9587, -15.8983, -16.6557], [-13.3109, -15.7350, -16.3141]],
						        [[-14.7074, -15.4352, -14.5944], [-16.6353, -18.1663, -18.6120], [-15.1702, -18.0329, -18.1547]],
						        [[-1.7990, -2.0951, -1.7784], [-2.6397, -3.8245, -3.9686], [-1.5264, -2.8126, -2.9316]],
						    ]							)
			else:
						__UpperCAmelCase	: Optional[int]		=					logits.argmax(-1							).item()
						print("Predicted class:"				,       model.config.idalabel[predicted_class_idx]							)

			# verify logits
			if not encoder_only:
						assert logits.shape == expected_shape
						assert torch.allclose(logits[0, :3, :3, :3]				,       UpperCamelCase				,       atol=1e-2							)

			# finally, save model and image processor
			logger.info(f"Saving PyTorch model and image processor to {pytorch_dump_folder_path}..."							)
			Path(UpperCamelCase							).mkdir(exist_ok=UpperCamelCase							)
			model.save_pretrained(UpperCamelCase							)
			image_processor.save_pretrained(UpperCamelCase							)


if __name__ == "__main__":
					A   =       argparse.ArgumentParser()

					parser.add_argument(
					    """--model_name""",
					    default="""segformer.b0.512x512.ade.160k""",
					    type=str,
					    help="""Name of the model you'd like to convert.""",
					)
					parser.add_argument(
					    """--checkpoint_path""", default=None, type=str, help="""Path to the original PyTorch checkpoint (.pth file)."""
					)
					parser.add_argument(
					    """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the folder to output PyTorch model."""
					)
					A   =       parser.parse_args()
					convert_segformer_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path)








"""simple docstring"""





import os
import re
import shutil
import sys
import tempfile
import unittest

import black


A   =       os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, """utils"""))

import check_copies  # noqa: E402


# This is the reference code that will be used in the tests.
# If BertLMPredictionHead is changed in modeling_bert.py, this code needs to be manually updated.
A   =       """    def __init__(self, config):
        super().__init__()
        self.transform = BertPredictionHeadTransform(config)

        # The output weights are the same as the input embeddings, but there is
        # an output-only bias for each token.
        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)

        self.bias = nn.Parameter(torch.zeros(config.vocab_size))

        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
        self.decoder.bias = self.bias

    def forward(self, hidden_states):
        hidden_states = self.transform(hidden_states)
        hidden_states = self.decoder(hidden_states)
        return hidden_states
"""



class      a__				(	unittest.TestCase   ):


			def       a_     (      self      :    Optional[Any]):


						"""simple docstring"""




						__UpperCAmelCase	: List[Any]		=					tempfile.mkdtemp()
						os.makedirs(os.path.join(self.transformer_dir      ,  "models/bert/"))
						__UpperCAmelCase	: Tuple		=					self.transformer_dir
						shutil.copy(
						    os.path.join(UpperCamelCase_      ,  "src/transformers/models/bert/modeling_bert.py")      ,  os.path.join(self.transformer_dir      ,  "models/bert/modeling_bert.py")      ,  )


			def       a_     (      self      :    int):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[Any]		=					"src/transformers"
						shutil.rmtree(self.transformer_dir)


			def       a_     (      self      :    str      ,  UpperCamelCase_      :    str      ,  UpperCamelCase_      :    int      ,  UpperCamelCase_      :    Optional[int]      ,  UpperCamelCase_      :    List[str]=None):


						"""simple docstring"""




						__UpperCAmelCase	: str		=					comment + F"\nclass {class_name}(nn.Module):\n" + class_code
						if overwrite_result is not None:
									__UpperCAmelCase	: str		=					comment + F"\nclass {class_name}(nn.Module):\n" + overwrite_result
						__UpperCAmelCase	: Optional[int]		=					black.Mode(target_versions={black.TargetVersion.PYaa}      ,  line_length=119)
						__UpperCAmelCase	: Dict		=					black.format_str(UpperCamelCase_      ,  mode=UpperCamelCase_)
						__UpperCAmelCase	: Dict		=					os.path.join(self.transformer_dir      ,  "new_code.py")
						with open(UpperCamelCase_      ,  "w"      ,  newline="\n") as f:
									f.write(UpperCamelCase_)
						if overwrite_result is None:
									self.assertTrue(len(check_copies.is_copy_consistent(UpperCamelCase_)) == 0)
						else:
									check_copies.is_copy_consistent(f.name      ,  overwrite=UpperCamelCase_)
									with open(UpperCamelCase_      ,  "r") as f:
												self.assertTrue(f.read()      ,  UpperCamelCase_)


			def       a_     (      self      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: Any		=					check_copies.find_code_in_transformers("models.bert.modeling_bert.BertLMPredictionHead")
						self.assertEqual(UpperCamelCase_      ,  UpperCamelCase_)


			def       a_     (      self      :    Optional[int]):


						"""simple docstring"""




						self.check_copy_consistency(
						    "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead"      ,  "BertLMPredictionHead"      ,  REFERENCE_CODE + "\n"      ,  )

						# With no empty line at the end
						self.check_copy_consistency(
						    "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead"      ,  "BertLMPredictionHead"      ,  UpperCamelCase_      ,  )

						# Copy consistency with rename
						self.check_copy_consistency(
						    "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel"      ,  "TestModelLMPredictionHead"      ,  re.sub("Bert"      ,  "TestModel"      ,  UpperCamelCase_)      ,  )

						# Copy consistency with a really long name
						__UpperCAmelCase	: Optional[Any]		=					"TestModelWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason"
						self.check_copy_consistency(
						    F"# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->{long_class_name}"      ,  F"{long_class_name}LMPredictionHead"      ,  re.sub("Bert"      ,  UpperCamelCase_      ,  UpperCamelCase_)      ,  )

						# Copy consistency with overwrite
						self.check_copy_consistency(
						    "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel"      ,  "TestModelLMPredictionHead"      ,  UpperCamelCase_      ,  overwrite_result=re.sub("Bert"      ,  "TestModel"      ,  UpperCamelCase_)      ,  )


			def       a_     (      self      :    Dict):


						"""simple docstring"""




						__UpperCAmelCase	: List[str]		=					check_copies.LOCALIZED_READMES["README_zh-hans.md"]

						__UpperCAmelCase	: str		=					(
						    "1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the"
						    " Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for"
						    " Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong"
						    " Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.\n1."
						    " **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (from HuggingFace),"
						    " released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and"
						    " lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same"
						    " method has been applied to compress GPT2 into"
						    " [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into"
						    " [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),"
						    " Multilingual BERT into"
						    " [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German"
						    " version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)**"
						    " (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders"
						    " as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang"
						    " Luong, Quoc V. Le, Christopher D. Manning."
						)
						__UpperCAmelCase	: List[str]		=					(
						    "1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"
						    " Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"
						    " Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"
						    " Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"
						)
						__UpperCAmelCase	: str		=					(
						    "1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"
						    " Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"
						    " Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"
						    " Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n1."
						    " **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (来自 HuggingFace) 伴随论文"
						    " [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and"
						    " lighter](https://arxiv.org/abs/1910.01108) 由 Victor Sanh, Lysandre Debut and Thomas Wolf 发布。 The same"
						    " method has been applied to compress GPT2 into"
						    " [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into"
						    " [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),"
						    " Multilingual BERT into"
						    " [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German"
						    " version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)** (来自"
						    " Google Research/Stanford University) 伴随论文 [ELECTRA: Pre-training text encoders as discriminators rather"
						    " than generators](https://arxiv.org/abs/2003.10555) 由 Kevin Clark, Minh-Thang Luong, Quoc V. Le,"
						    " Christopher D. Manning 发布。\n"
						)

						__UpperCAmelCase	,     __UpperCAmelCase	: Any		=					check_copies.convert_to_localized_md(
						    UpperCamelCase_      ,  UpperCamelCase_      ,  localized_readme["format_model_list"])

						self.assertFalse(UpperCamelCase_)
						self.assertEqual(UpperCamelCase_      ,  UpperCamelCase_)

						__UpperCAmelCase	,     __UpperCAmelCase	: int		=					check_copies.convert_to_localized_md(
						    UpperCamelCase_      ,  UpperCamelCase_      ,  localized_readme["format_model_list"])

						# Check whether the number of models is equal to README.md after conversion.
						self.assertTrue(UpperCamelCase_)

						__UpperCAmelCase	: str		=					(
						    "1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the"
						    " Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for"
						    " Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong"
						    " Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut."
						)
						__UpperCAmelCase	: Optional[int]		=					(
						    "1. **[ALBERT](https://huggingface.co/transformers/main/model_doc/albert.html)** (来自 Google Research and"
						    " the Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"
						    " Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"
						    " Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"
						)
						__UpperCAmelCase	: int		=					(
						    "1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the"
						    " Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of"
						    " Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian"
						    " Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n"
						)

						__UpperCAmelCase	,     __UpperCAmelCase	: List[str]		=					check_copies.convert_to_localized_md(
						    UpperCamelCase_      ,  UpperCamelCase_      ,  localized_readme["format_model_list"])

						# Check if the model link is synchronized.
						self.assertEqual(UpperCamelCase_      ,  UpperCamelCase_)


