



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

import black


lowerCAmelCase__	    =    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.
lowerCAmelCase__	    =    '''    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  snake_case__(unittest.TestCase     ):

					"""simple docstring"""






					def 					snake_case	(				self   :      str	):
									lowercase__	:       int						=	tempfile.mkdtemp()
									os.makedirs(os.path.join(self.transformer_dir ,  "models/bert/"	)	)
									lowercase__	:       List[str]						=	self.transformer_dir
									shutil.copy(
									    os.path.join(_lowerCAmelCase ,  "src/transformers/models/bert/modeling_bert.py"	) ,  os.path.join(self.transformer_dir ,  "models/bert/modeling_bert.py"	) ,  )







					def 					snake_case	(				self   :      List[Any]	):
									lowercase__	:       int						=	"src/transformers"
									shutil.rmtree(self.transformer_dir	)







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







					def 					snake_case	(				self   :      Any	):
									lowercase__	:       str						=	check_copies.find_code_in_transformers("models.bert.modeling_bert.BertLMPredictionHead"	)
									self.assertEqual(_lowerCAmelCase ,  _lowerCAmelCase	)







					def 					snake_case	(				self   :      Union[str, Any]	):
									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" ,  _lowerCAmelCase ,  )

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

									# Copy consistency with a really long name
									lowercase__	:       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" ,  _lowerCAmelCase ,  _lowerCAmelCase	) ,  )

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







					def 					snake_case	(				self   :      Optional[int]	):
									lowercase__	:       Any						=	check_copies.LOCALIZED_READMES["README_zh-hans.md"]

									lowercase__	:       Any						=	(
									    "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."
									)
									lowercase__	:       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"
									)
									lowercase__	:       Tuple						=	(
									    "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"
									)

									lowercase__				,				lowercase__	:       str						=	check_copies.convert_to_localized_md(
									    _lowerCAmelCase ,  _lowerCAmelCase ,  localized_readme["format_model_list"]	)

									self.assertFalse(_lowerCAmelCase	)
									self.assertEqual(_lowerCAmelCase ,  _lowerCAmelCase	)

									lowercase__				,				lowercase__	:       Dict						=	check_copies.convert_to_localized_md(
									    _lowerCAmelCase ,  _lowerCAmelCase ,  localized_readme["format_model_list"]	)

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

									lowercase__	:       int						=	(
									    "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."
									)
									lowercase__	:       Tuple						=	(
									    "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"
									)
									lowercase__	:       Any						=	(
									    "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"
									)

									lowercase__				,				lowercase__	:       str						=	check_copies.convert_to_localized_md(
									    _lowerCAmelCase ,  _lowerCAmelCase ,  localized_readme["format_model_list"]	)

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








from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
   import PIL


SCREAMING_SNAKE_CASE						:List[Any]			=  logging.get_logger(__name__)


class      __lowerCAmelCase  (			a       ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE		     =							['pixel_values']



  def __init__(  self							:							Optional[int]     ,					_lowerCAmelCase							:							bool = True     ,					_lowerCAmelCase							:							Dict[str, int] = None     ,					_lowerCAmelCase							:							PILImageResampling = PIL.Image.BICUBIC     ,					_lowerCAmelCase							:							bool = True     ,					_lowerCAmelCase							:							Dict[str, int] = None     ,					_lowerCAmelCase							:							Union[int, float] = 1 / 2_5_5     ,					_lowerCAmelCase							:							bool = True     ,					_lowerCAmelCase							:							bool = True     ,					_lowerCAmelCase							:							Optional[Union[float, List[float]]] = None     ,					_lowerCAmelCase							:							Optional[Union[float, List[float]]] = None     ,					**_lowerCAmelCase							:							Optional[Any]     ,					) ->			None:




     """simple docstring"""
     super().__init__(**_lowerCAmelCase	)
     snake_case_            =       size if size is not None else {"height": 2_5_6, "width": 2_5_6}
     snake_case_            =       get_size_dict(_lowerCAmelCase	)
     snake_case_            =       crop_size if crop_size is not None else {"height": 2_2_4, "width": 2_2_4}
     snake_case_            =       get_size_dict(_lowerCAmelCase     ,					param_name="crop_size"	)

     snake_case_            =       do_resize
     snake_case_            =       size
     snake_case_            =       resample
     snake_case_            =       do_center_crop
     snake_case_            =       crop_size
     snake_case_            =       do_rescale
     snake_case_            =       rescale_factor
     snake_case_            =       do_normalize
     snake_case_            =       image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
     snake_case_            =       image_std if image_std is not None else IMAGENET_STANDARD_STD



  def        lowerCAmelCase__	(  self							:							List[str]     ,					_lowerCAmelCase							:							np.ndarray     ,					_lowerCAmelCase							:							Dict[str, int]     ,					_lowerCAmelCase							:							PILImageResampling = PIL.Image.BICUBIC     ,					_lowerCAmelCase							:							Optional[Union[str, ChannelDimension]] = None     ,					**_lowerCAmelCase							:							int     ,					) ->			np.ndarray:




     """simple docstring"""
     snake_case_            =       get_size_dict(_lowerCAmelCase	)
     if "height" not in size or "width" not in size:
        raise ValueError(F'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'''	)
     return resize(
         _lowerCAmelCase     ,					size=(size["height"], size["width"])     ,					resample=_lowerCAmelCase     ,					data_format=_lowerCAmelCase     ,					**_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							Optional[Any]     ,					_lowerCAmelCase							:							np.ndarray     ,					_lowerCAmelCase							:							Dict[str, int]     ,					_lowerCAmelCase							:							Optional[Union[str, ChannelDimension]] = None     ,					**_lowerCAmelCase							:							int     ,					) ->			np.ndarray:




     """simple docstring"""
     snake_case_            =       get_size_dict(_lowerCAmelCase	)
     if "height" not in size or "width" not in size:
        raise ValueError(F'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'''	)
     return center_crop(_lowerCAmelCase     ,					size=(size["height"], size["width"])     ,					data_format=_lowerCAmelCase     ,					**_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							Optional[Any]     ,					_lowerCAmelCase							:							np.ndarray     ,					_lowerCAmelCase							:							Union[int, float]     ,					_lowerCAmelCase							:							Optional[Union[str, ChannelDimension]] = None     ,					**_lowerCAmelCase							:							Union[str, Any]     ,					) ->			Optional[Any]:




     """simple docstring"""
     return rescale(_lowerCAmelCase     ,					scale=_lowerCAmelCase     ,					data_format=_lowerCAmelCase     ,					**_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							Optional[Any]     ,					_lowerCAmelCase							:							np.ndarray     ,					_lowerCAmelCase							:							Union[float, List[float]]     ,					_lowerCAmelCase							:							Union[float, List[float]]     ,					_lowerCAmelCase							:							Optional[Union[str, ChannelDimension]] = None     ,					**_lowerCAmelCase							:							Any     ,					) ->			np.ndarray:




     """simple docstring"""
     return normalize(_lowerCAmelCase     ,					mean=_lowerCAmelCase     ,					std=_lowerCAmelCase     ,					data_format=_lowerCAmelCase     ,					**_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							Optional[Any]     ,					_lowerCAmelCase							:							ImageInput     ,					_lowerCAmelCase							:							bool = None     ,					_lowerCAmelCase							:							Dict[str, int] = None     ,					_lowerCAmelCase							:							int=None     ,					_lowerCAmelCase							:							bool = None     ,					_lowerCAmelCase							:							Dict[str, int] = None     ,					_lowerCAmelCase							:							bool = None     ,					_lowerCAmelCase							:							float = None     ,					_lowerCAmelCase							:							bool = None     ,					_lowerCAmelCase							:							Optional[Union[float, List[float]]] = None     ,					_lowerCAmelCase							:							Optional[Union[float, List[float]]] = None     ,					_lowerCAmelCase							:							Optional[Union[str, TensorType]] = None     ,					_lowerCAmelCase							:							ChannelDimension = ChannelDimension.FIRST     ,					**_lowerCAmelCase							:							Tuple     ,					) ->			PIL.Image.Image:




     """simple docstring"""
     snake_case_            =       do_resize if do_resize is not None else self.do_resize
     snake_case_            =       resample if resample is not None else self.resample
     snake_case_            =       do_center_crop if do_center_crop is not None else self.do_center_crop
     snake_case_            =       do_rescale if do_rescale is not None else self.do_rescale
     snake_case_            =       rescale_factor if rescale_factor is not None else self.rescale_factor
     snake_case_            =       do_normalize if do_normalize is not None else self.do_normalize
     snake_case_            =       image_mean if image_mean is not None else self.image_mean
     snake_case_            =       image_std if image_std is not None else self.image_std

     snake_case_            =       size if size is not None else self.size
     snake_case_            =       get_size_dict(_lowerCAmelCase	)
     snake_case_            =       crop_size if crop_size is not None else self.crop_size
     snake_case_            =       get_size_dict(_lowerCAmelCase     ,					param_name="crop_size"	)

     snake_case_            =       make_list_of_images(_lowerCAmelCase	)

     if not valid_images(_lowerCAmelCase	):
        raise ValueError(
            "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
            "torch.Tensor, tf.Tensor or jax.ndarray."	)

     if do_resize and size is None or resample is None:
        raise ValueError("Size and resample must be specified if do_resize is True."	)

     if do_center_crop and crop_size is None:
        raise ValueError("Crop size must be specified if do_center_crop is True."	)

     if do_rescale and rescale_factor is None:
        raise ValueError("Rescale factor must be specified if do_rescale is True."	)

     if do_normalize and (image_mean is None or image_std is None):
        raise ValueError("Image mean and std must be specified if do_normalize is True."	)

     # All transformations expect numpy arrays.
     snake_case_            =       [to_numpy_array(_lowerCAmelCase	) for image in images]

     if do_resize:
        snake_case_            =       [self.resize(image=_lowerCAmelCase     ,					size=_lowerCAmelCase     ,					resample=_lowerCAmelCase	) for image in images]

     if do_center_crop:
        snake_case_            =       [self.center_crop(image=_lowerCAmelCase     ,					size=_lowerCAmelCase	) for image in images]

     if do_rescale:
        snake_case_            =       [self.rescale(image=_lowerCAmelCase     ,					scale=_lowerCAmelCase	) for image in images]

     if do_normalize:
        snake_case_            =       [self.normalize(image=_lowerCAmelCase     ,					mean=_lowerCAmelCase     ,					std=_lowerCAmelCase	) for image in images]

     snake_case_            =       [to_channel_dimension_format(_lowerCAmelCase     ,					_lowerCAmelCase	) for image in images]

     snake_case_            =       {"pixel_values": images}
     return BatchFeature(data=_lowerCAmelCase     ,					tensor_type=_lowerCAmelCase	)




