
'''simple docstring'''







import gc
import math
import unittest

import torch

from diffusers import UNetaDModel
from diffusers.utils import floats_tensor, logging, slow, torch_all_close, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


lowercase					:							Optional[int]   =      logging.get_logger(__name__)

enable_full_determinism()


class 		__UpperCAmelCase   (      _lowerCamelCase		,     _lowerCamelCase		,     unittest.TestCase		):
							__lowercase   	= UNetaDModel
							__lowercase   	= """sample"""


							@property
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	4
								_snake_case     		=	3
								_snake_case     		=	(32, 32)

								_snake_case     		=	floats_tensor((batch_size, num_channels) + sizes						).to(lowerCAmelCase_						)
								_snake_case     		=	torch.tensor([10]						).to(lowerCAmelCase_						)

								return {"sample": noise, "timestep": time_step}


							@property
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								return (3, 32, 32)


							@property
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								return (3, 32, 32)




							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	{
								    'block_out_channels': (32, 64),
								    'down_block_types': ('DownBlock2D', 'AttnDownBlock2D'),
								    'up_block_types': ('AttnUpBlock2D', 'UpBlock2D'),
								    'attention_head_dim': 3,
								    'out_channels': 3,
								    'in_channels': 3,
								    'layers_per_block': 2,
								    'sample_size': 32,
								}
								_snake_case     		=	self.dummy_input
								return init_dict, inputs_dict


class 		__UpperCAmelCase   (      _lowerCamelCase		,     _lowerCamelCase		,     unittest.TestCase		):
							__lowercase   	= UNetaDModel
							__lowercase   	= """sample"""


							@property
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	4
								_snake_case     		=	4
								_snake_case     		=	(32, 32)

								_snake_case     		=	floats_tensor((batch_size, num_channels) + sizes						).to(lowerCAmelCase_						)
								_snake_case     		=	torch.tensor([10]						).to(lowerCAmelCase_						)

								return {"sample": noise, "timestep": time_step}


							@property
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								return (4, 32, 32)


							@property
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								return (4, 32, 32)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	{
								    'sample_size': 32,
								    'in_channels': 4,
								    'out_channels': 4,
								    'layers_per_block': 2,
								    'block_out_channels': (32, 64),
								    'attention_head_dim': 32,
								    'down_block_types': ('DownBlock2D', 'DownBlock2D'),
								    'up_block_types': ('UpBlock2D', 'UpBlock2D'),
								}
								_snake_case     		=	self.dummy_input
								return init_dict, inputs_dict


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case		,				_snake_case     		=	UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update'					,     output_loading_info=lowerCAmelCase_						)

								self.assertIsNotNone(lowerCAmelCase_						)
								self.assertEqual(len(loading_info['missing_keys']						)					,     0						)

								model.to(lowerCAmelCase_						)
								_snake_case     		=	model(**self.dummy_input						).sample

								assert image is not None, "Make sure output is not None"


							@unittest.skipIf(torch_device != 'cuda'					,     'This test is supposed to run on GPU'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case		,				_snake_case     		=	UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update'					,     output_loading_info=lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								_snake_case     		=	model(**self.dummy_input						).sample

								assert image is not None, "Make sure output is not None"


							@unittest.skipIf(torch_device != 'cuda'					,     'This test is supposed to run on GPU'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case		,				_snake_case     		=	UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update'					,     output_loading_info=lowerCAmelCase_						)
								model_accelerate.to(lowerCAmelCase_						)
								model_accelerate.eval()

								_snake_case     		=	torch.randn(
								    1					,     model_accelerate.config.in_channels					,     model_accelerate.config.sample_size					,     model_accelerate.config.sample_size					,     generator=torch.manual_seed(0						)					,     )
								_snake_case     		=	noise.to(lowerCAmelCase_						)
								_snake_case     		=	torch.tensor([10] * noise.shape[0]						).to(lowerCAmelCase_						)

								_snake_case     		=	model_accelerate(lowerCAmelCase_					,     lowerCAmelCase_						)['sample']

								# two models don't need to stay in the device at the same time
								del model_accelerate
								torch.cuda.empty_cache()
								gc.collect()

								_snake_case		,				_snake_case     		=	UNetaDModel.from_pretrained(
								    'fusing/unet-ldm-dummy-update'					,     output_loading_info=lowerCAmelCase_					,     low_cpu_mem_usage=lowerCAmelCase_						)
								model_normal_load.to(lowerCAmelCase_						)
								model_normal_load.eval()
								_snake_case     		=	model_normal_load(lowerCAmelCase_					,     lowerCAmelCase_						)['sample']

								assert torch_all_close(lowerCAmelCase_					,     lowerCAmelCase_					,     rtol=1E-3						)




							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update'						)
								model.eval()
								model.to(lowerCAmelCase_						)

								_snake_case     		=	torch.randn(
								    1					,     model.config.in_channels					,     model.config.sample_size					,     model.config.sample_size					,     generator=torch.manual_seed(0						)					,     )
								_snake_case     		=	noise.to(lowerCAmelCase_						)
								_snake_case     		=	torch.tensor([10] * noise.shape[0]						).to(lowerCAmelCase_						)

								with torch.no_grad():
									_snake_case     		=	model(lowerCAmelCase_					,     lowerCAmelCase_						).sample

								_snake_case     		=	output[0, -1, -3:, -3:].flatten().cpu()
								# fmt: off
								_snake_case     		=	torch.tensor([-13.3258, -20.1100, -15.9873, -17.6617, -23.0596, -17.9419, -13.3675, -16.1889, -12.3800]						)
								# fmt: on

								self.assertTrue(torch_all_close(lowerCAmelCase_					,     lowerCAmelCase_					,     rtol=1E-3						)						)


class 		__UpperCAmelCase   (      _lowerCamelCase		,     _lowerCamelCase		,     unittest.TestCase		):
							__lowercase   	= UNetaDModel
							__lowercase   	= """sample"""


							@property
							def 				lowerCamelCase       ( self					,     lowerCAmelCase_=(32, 32)						):





								"""simple docstring"""






								_snake_case     		=	4
								_snake_case     		=	3

								_snake_case     		=	floats_tensor((batch_size, num_channels) + sizes						).to(lowerCAmelCase_						)
								_snake_case     		=	torch.tensor(batch_size * [10]						).to(dtype=torch.intaa					,     device=lowerCAmelCase_						)

								return {"sample": noise, "timestep": time_step}


							@property
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								return (3, 32, 32)


							@property
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								return (3, 32, 32)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	{
								    'block_out_channels': [32, 64, 64, 64],
								    'in_channels': 3,
								    'layers_per_block': 1,
								    'out_channels': 3,
								    'time_embedding_type': 'fourier',
								    'norm_eps': 1E-6,
								    'mid_block_scale_factor': math.sqrt(2.0						),
								    'norm_num_groups': None,
								    'down_block_types': [
								        'SkipDownBlock2D',
								        'AttnSkipDownBlock2D',
								        'SkipDownBlock2D',
								        'SkipDownBlock2D',
								    ],
								    'up_block_types': [
								        'SkipUpBlock2D',
								        'SkipUpBlock2D',
								        'AttnSkipUpBlock2D',
								        'SkipUpBlock2D',
								    ],
								}
								_snake_case     		=	self.dummy_input
								return init_dict, inputs_dict


							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case		,				_snake_case     		=	UNetaDModel.from_pretrained('google/ncsnpp-celebahq-256'					,     output_loading_info=lowerCAmelCase_						)
								self.assertIsNotNone(lowerCAmelCase_						)
								self.assertEqual(len(loading_info['missing_keys']						)					,     0						)

								model.to(lowerCAmelCase_						)
								_snake_case     		=	self.dummy_input
								_snake_case     		=	floats_tensor((4, 3) + (2_56, 2_56)						).to(lowerCAmelCase_						)
								_snake_case     		=	noise
								_snake_case     		=	model(**lowerCAmelCase_						)

								assert image is not None, "Make sure output is not None"


							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	UNetaDModel.from_pretrained('google/ncsnpp-celebahq-256'						)
								model.to(lowerCAmelCase_						)

								_snake_case     		=	4
								_snake_case     		=	3
								_snake_case     		=	(2_56, 2_56)

								_snake_case     		=	torch.ones((batch_size, num_channels) + sizes						).to(lowerCAmelCase_						)
								_snake_case     		=	torch.tensor(batch_size * [1E-4]						).to(lowerCAmelCase_						)

								with torch.no_grad():
									_snake_case     		=	model(lowerCAmelCase_					,     lowerCAmelCase_						).sample

								_snake_case     		=	output[0, -3:, -3:, -1].flatten().cpu()
								# fmt: off
								_snake_case     		=	torch.tensor([-4842.8691, -6499.6631, -3800.1953, -7978.2686, -10980.7129, -20028.8535, 8148.2822, 2342.2905, 567.7608]						)
								# fmt: on

								self.assertTrue(torch_all_close(lowerCAmelCase_					,     lowerCAmelCase_					,     rtol=1E-2						)						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	UNetaDModel.from_pretrained('fusing/ncsnpp-ffhq-ve-dummy-update'						)
								model.to(lowerCAmelCase_						)

								_snake_case     		=	4
								_snake_case     		=	3
								_snake_case     		=	(32, 32)

								_snake_case     		=	torch.ones((batch_size, num_channels) + sizes						).to(lowerCAmelCase_						)
								_snake_case     		=	torch.tensor(batch_size * [1E-4]						).to(lowerCAmelCase_						)

								with torch.no_grad():
									_snake_case     		=	model(lowerCAmelCase_					,     lowerCAmelCase_						).sample

								_snake_case     		=	output[0, -3:, -3:, -1].flatten().cpu()
								# fmt: off
								_snake_case     		=	torch.tensor([-0.0325, -0.0900, -0.0869, -0.0332, -0.0725, -0.0270, -0.0101, 0.0227, 0.0256]						)
								# fmt: on

								self.assertTrue(torch_all_close(lowerCAmelCase_					,     lowerCAmelCase_					,     rtol=1E-2						)						)




							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass



'''simple docstring'''







import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


lowercase					:							str   =      version.parse(importlib_metadata.version("nltk"))
if NLTK_VERSION >= version.Version("3.6.4"):
					from nltk import word_tokenize


lowercase					:							int   =      "\\n@inproceedings{banarjee2005,\n  title     = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n  author    = {Banerjee, Satanjeev  and Lavie, Alon},\n  booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n  month     = jun,\n  year      = {2005},\n  address   = {Ann Arbor, Michigan},\n  publisher = {Association for Computational Linguistics},\n  url       = {https://www.aclweb.org/anthology/W05-0909},\n  pages     = {65--72},\n}\n"

lowercase					:							Any   =      "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n"

lowercase					:							Optional[Any]   =      "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n    predictions: list of predictions to score. Each prediction\n        should be a string with tokens separated by spaces.\n    references: list of reference for each prediction. Each\n        reference should be a string with tokens separated by spaces.\n    alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n    beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n    gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n    'meteor': meteor score.\nExamples:\n\n    >>> meteor = datasets.load_metric('meteor')\n    >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n    >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n    >>> results = meteor.compute(predictions=predictions, references=references)\n    >>> print(round(results[\"meteor\"], 4))\n    0.6944\n"


@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION		,     _KWARGS_DESCRIPTION		)
class 		__UpperCAmelCase   (      datasets.Metric		):


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								return datasets.MetricInfo(
								    description=_DESCRIPTION					,     citation=_CITATION					,     inputs_description=_KWARGS_DESCRIPTION					,     features=datasets.Features(
								        {
								            'predictions': datasets.Value('string'					,     id='sequence'						),
								            'references': datasets.Value('string'					,     id='sequence'						),
								        }						)					,     codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py']					,     reference_urls=[
								        'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score',
								        'https://en.wikipedia.org/wiki/METEOR',
								    ]					,     )


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								import nltk

								nltk.download('wordnet'						)
								if NLTK_VERSION >= version.Version('3.6.5'						):
									nltk.download('punkt'						)
								if NLTK_VERSION >= version.Version('3.6.6'						):
									nltk.download('omw-1.4'						)




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_=0.9					,     lowerCAmelCase_=3					,     lowerCAmelCase_=0.5						):





								"""simple docstring"""






								if NLTK_VERSION >= version.Version('3.6.5'						):
									_snake_case     		=	[
									    meteor_score.single_meteor_score(
									        word_tokenize(lowerCAmelCase_						)					,     word_tokenize(lowerCAmelCase_						)					,     alpha=lowerCAmelCase_					,     beta=lowerCAmelCase_					,     gamma=lowerCAmelCase_						)
									    for ref, pred in zip(lowerCAmelCase_					,     lowerCAmelCase_						)
									]
								else:
									_snake_case     		=	[
									    meteor_score.single_meteor_score(lowerCAmelCase_					,     lowerCAmelCase_					,     alpha=lowerCAmelCase_					,     beta=lowerCAmelCase_					,     gamma=lowerCAmelCase_						)
									    for ref, pred in zip(lowerCAmelCase_					,     lowerCAmelCase_						)
									]

								return {"meteor": np.mean(lowerCAmelCase_						)}

