






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

import black


__UpperCamelCase      :      Optional[Any]     						=						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.
__UpperCamelCase      :      int     						=						"""    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        __UpperCamelCase    (     unittest.TestCase   ):







	def  _a   (  self      :							List[str]			)		-> Union[str, Any]:
		"""simple docstring"""







		__lowercase             =  tempfile.mkdtemp()
		os.makedirs(os.path.join(self.transformer_dir       ,				"""models/bert/"""			)			)
		__lowercase             =  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  _a   (  self      :							Any			)		-> List[str]:
		"""simple docstring"""







		__lowercase             =  """src/transformers"""
		shutil.rmtree(self.transformer_dir			)







	def  _a   (  self      :							List[Any]       ,				_lowerCAmelCase      :							str       ,				_lowerCAmelCase      :							Optional[Any]       ,				_lowerCAmelCase      :							Tuple       ,				_lowerCAmelCase      :							Optional[Any]=None			)		-> str:
		"""simple docstring"""







		__lowercase             =  comment + F'\nclass {class_name}(nn.Module):\n' + class_code
		if overwrite_result is not None:
			__lowercase             =  comment + F'\nclass {class_name}(nn.Module):\n' + overwrite_result
		__lowercase             =  black.Mode(target_versions={black.TargetVersion.PYaa}       ,				line_length=119			)
		__lowercase             =  black.format_str(_lowerCAmelCase       ,				mode=_lowerCAmelCase			)
		__lowercase             =  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  _a   (  self      :							Union[str, Any]			)		-> str:
		"""simple docstring"""







		__lowercase             =  check_copies.find_code_in_transformers("""models.bert.modeling_bert.BertLMPredictionHead"""			)
		self.assertEqual(_lowerCAmelCase       ,				_lowerCAmelCase			)







	def  _a   (  self      :							List[str]			)		-> List[str]:
		"""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"""       ,				_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             =  """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  _a   (  self      :							List[Any]			)		-> List[str]:
		"""simple docstring"""







		__lowercase             =  check_copies.LOCALIZED_READMES["""README_zh-hans.md"""]

		__lowercase             =  (
		    """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             =  (
		    """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             =  (
		    """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             =  check_copies.convert_to_localized_md(
		    _lowerCAmelCase       ,				_lowerCAmelCase       ,				localized_readme["""format_model_list"""]			)

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

		__lowercase       ,						__lowercase             =  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             =  (
		    """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             =  (
		    """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             =  (
		    """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             =  check_copies.convert_to_localized_md(
		    _lowerCAmelCase       ,				_lowerCAmelCase       ,				localized_readme["""format_model_list"""]			)

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









import torch

from diffusers import UnCLIPScheduler

from .test_schedulers import SchedulerCommonTest


class        __UpperCamelCase    (     _lowerCAmelCase   ):
	__snake_case	:str   =       (UnCLIPScheduler,)







	def  _a   (  self      :							Optional[int]       ,				**_lowerCAmelCase      :							Any			)		-> Tuple:
		"""simple docstring"""







		__lowercase             =  {
		    """num_train_timesteps""": 1000,
		    """variance_type""": """fixed_small_log""",
		    """clip_sample""": True,
		    """clip_sample_range""": 1.0,
		    """prediction_type""": """epsilon""",
		}

		config.update(**_lowerCAmelCase			)
		return config







	def  _a   (  self      :							Dict			)		-> List[Any]:
		"""simple docstring"""







		for timesteps in [1, 5, 100, 1000]:
			self.check_over_configs(num_train_timesteps=_lowerCAmelCase			)







	def  _a   (  self      :							List[str]			)		-> Tuple:
		"""simple docstring"""







		for variance in ["fixed_small_log", "learned_range"]:
			self.check_over_configs(variance_type=_lowerCAmelCase			)







	def  _a   (  self      :							Any			)		-> Any:
		"""simple docstring"""







		for clip_sample in [True, False]:
			self.check_over_configs(clip_sample=_lowerCAmelCase			)







	def  _a   (  self      :							Any			)		-> Optional[Any]:
		"""simple docstring"""







		for clip_sample_range in [1, 5, 10, 20]:
			self.check_over_configs(clip_sample_range=_lowerCAmelCase			)







	def  _a   (  self      :							Optional[int]			)		-> Tuple:
		"""simple docstring"""







		for prediction_type in ["epsilon", "sample"]:
			self.check_over_configs(prediction_type=_lowerCAmelCase			)







	def  _a   (  self      :							str			)		-> int:
		"""simple docstring"""







		for time_step in [0, 500, 999]:
			for prev_timestep in [None, 5, 100, 250, 500, 750]:
				if prev_timestep is not None and prev_timestep >= time_step:
					continue

				self.check_over_forward(time_step=_lowerCAmelCase       ,				prev_timestep=_lowerCAmelCase			)







	def  _a   (  self      :							Union[str, Any]			)		-> Tuple:
		"""simple docstring"""







		__lowercase             =  self.scheduler_classes[0]
		__lowercase             =  self.get_scheduler_config(variance_type="""fixed_small_log"""			)
		__lowercase             =  scheduler_class(**_lowerCAmelCase			)

		assert torch.sum(torch.abs(scheduler._get_variance(0			) - 1.0000e-10			)			) < 1e-5
		assert torch.sum(torch.abs(scheduler._get_variance(487			) - 0.0_549_625			)			) < 1e-5
		assert torch.sum(torch.abs(scheduler._get_variance(999			) - 0.9_994_987			)			) < 1e-5







	def  _a   (  self      :							str			)		-> Optional[int]:
		"""simple docstring"""







		__lowercase             =  self.scheduler_classes[0]
		__lowercase             =  self.get_scheduler_config(variance_type="""learned_range"""			)
		__lowercase             =  scheduler_class(**_lowerCAmelCase			)

		__lowercase             =  0.5

		assert scheduler._get_variance(1       ,				predicted_variance=_lowerCAmelCase			) - -10.1_712_790 < 1e-5
		assert scheduler._get_variance(487       ,				predicted_variance=_lowerCAmelCase			) - -5.7_998_052 < 1e-5
		assert scheduler._get_variance(999       ,				predicted_variance=_lowerCAmelCase			) - -0.0_010_011 < 1e-5







	def  _a   (  self      :							Optional[Any]			)		-> List[Any]:
		"""simple docstring"""







		__lowercase             =  self.scheduler_classes[0]
		__lowercase             =  self.get_scheduler_config()
		__lowercase             =  scheduler_class(**_lowerCAmelCase			)

		__lowercase             =  scheduler.timesteps

		__lowercase             =  self.dummy_model()
		__lowercase             =  self.dummy_sample_deter
		__lowercase             =  torch.manual_seed(0			)

		for i, t in enumerate(_lowerCAmelCase			):
			# 1. predict noise residual
			__lowercase             =  model(_lowerCAmelCase       ,				_lowerCAmelCase			)

			# 2. predict previous mean of sample x_t-1
			__lowercase             =  scheduler.step(_lowerCAmelCase       ,				_lowerCAmelCase       ,				_lowerCAmelCase       ,				generator=_lowerCAmelCase			).prev_sample

			__lowercase             =  pred_prev_sample

		__lowercase             =  torch.sum(torch.abs(_lowerCAmelCase			)			)
		__lowercase             =  torch.mean(torch.abs(_lowerCAmelCase			)			)

		assert abs(result_sum.item() - 252.2_682_495			) < 1e-2
		assert abs(result_mean.item() - 0.3_284_743			) < 1e-3







	def  _a   (  self      :							List[str]			)		-> str:
		"""simple docstring"""







		__lowercase             =  self.scheduler_classes[0]
		__lowercase             =  self.get_scheduler_config()
		__lowercase             =  scheduler_class(**_lowerCAmelCase			)

		scheduler.set_timesteps(25			)

		__lowercase             =  scheduler.timesteps

		__lowercase             =  self.dummy_model()
		__lowercase             =  self.dummy_sample_deter
		__lowercase             =  torch.manual_seed(0			)

		for i, t in enumerate(_lowerCAmelCase			):
			# 1. predict noise residual
			__lowercase             =  model(_lowerCAmelCase       ,				_lowerCAmelCase			)

			if i + 1 == timesteps.shape[0]:
				__lowercase             =  None
			else:
				__lowercase             =  timesteps[i + 1]

			# 2. predict previous mean of sample x_t-1
			__lowercase             =  scheduler.step(
			    _lowerCAmelCase       ,				_lowerCAmelCase       ,				_lowerCAmelCase       ,				prev_timestep=_lowerCAmelCase       ,				generator=_lowerCAmelCase			).prev_sample

			__lowercase             =  pred_prev_sample

		__lowercase             =  torch.sum(torch.abs(_lowerCAmelCase			)			)
		__lowercase             =  torch.mean(torch.abs(_lowerCAmelCase			)			)

		assert abs(result_sum.item() - 258.2_044_983			) < 1e-2
		assert abs(result_mean.item() - 0.3_362_038			) < 1e-3







	def  _a   (  self      :							str			)		-> Union[str, Any]:
		"""simple docstring"""







		pass







	def  _a   (  self      :							int			)		-> List[str]:
		"""simple docstring"""







		pass

