


"""simple docstring"""




import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin
@skip_mps
class 					lowerCAmelCase	(					lowerCamelCase_	,    lowerCamelCase_	,    unittest.TestCase    ):




		'''simple docstring'''







		SCREAMING_SNAKE_CASE_						:     Union[str, Any]								=     IFPipeline
		SCREAMING_SNAKE_CASE_						:     Tuple								=     TEXT_TO_IMAGE_PARAMS - {"""width""", """height""", """latents"""}
		SCREAMING_SNAKE_CASE_						:     str								=     TEXT_TO_IMAGE_BATCH_PARAMS
		SCREAMING_SNAKE_CASE_						:     str								=     PipelineTesterMixin.required_optional_params - {"""latents"""}







		def 							__A						(	self				)     ->							Tuple:
								return self._get_dummy_components()







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__=0				)     ->							List[Any]:
								if str(lowerCAmelCase__				).startswith('mps'				):
														SCREAMING_SNAKE_CASE													=					torch.manual_seed(lowerCAmelCase__				)
								else:
														SCREAMING_SNAKE_CASE													=					torch.Generator(device=lowerCAmelCase__				).manual_seed(lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					{
								    'prompt': 'A painting of a squirrel eating a burger',
								    'generator': generator,
								    'num_inference_steps': 2,
								    'output_type': 'numpy',
								}

								return inputs







		def 							__A						(	self				)     ->							Dict:
								self._test_save_load_optional_components()







		@unittest.skipIf(torch_device != 'cuda'						,       reason='float16 requires CUDA'				)
		def 							__A						(	self				)     ->							Union[str, Any]:
								# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
								super().test_save_load_floataa(expected_max_diff=1e-1				)







		def 							__A						(	self				)     ->							Optional[int]:
								self._test_attention_slicing_forward_pass(expected_max_diff=1e-2				)







		def 							__A						(	self				)     ->							List[str]:
								self._test_save_load_local()







		def 							__A						(	self				)     ->							Tuple:
								self._test_inference_batch_single_identical(
								    expected_max_diff=1e-2						,       )







		@unittest.skipIf(
		    torch_device != 'cuda' or not is_xformers_available()						,       reason='XFormers attention is only available with CUDA and `xformers` installed'						,       )
		def 							__A						(	self				)     ->							Union[str, Any]:
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3				)





@slow
@require_torch_gpu
class 					lowerCAmelCase	(					unittest.TestCase    ):




		'''simple docstring'''







		def 							__A						(	self				)     ->							Optional[int]:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()







		def 							__A						(	self				)     ->							List[Any]:
								# if

								SCREAMING_SNAKE_CASE													=					IFPipeline.from_pretrained('DeepFloyd/IF-I-XL-v1.0'						,       variant='fp16'						,       torch_dtype=torch.floataa				)

								SCREAMING_SNAKE_CASE													=					IFSuperResolutionPipeline.from_pretrained(
								    'DeepFloyd/IF-II-L-v1.0'						,       variant='fp16'						,       torch_dtype=torch.floataa						,       text_encoder=lowerCAmelCase__						,       tokenizer=lowerCAmelCase__				)

								# pre compute text embeddings and remove T5 to save memory

								pipe_a.text_encoder.to('cuda'				)

								SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					pipe_a.encode_prompt('anime turtle'						,       device='cuda'				)

								del pipe_a.tokenizer
								del pipe_a.text_encoder
								gc.collect()

								SCREAMING_SNAKE_CASE													=					None
								SCREAMING_SNAKE_CASE													=					None

								pipe_a.enable_model_cpu_offload()
								pipe_a.enable_model_cpu_offload()

								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)
								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)

								self._test_if(lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__				)

								pipe_a.remove_all_hooks()
								pipe_a.remove_all_hooks()

								# img2img

								SCREAMING_SNAKE_CASE													=					IFImgaImgPipeline(**pipe_a.components				)
								SCREAMING_SNAKE_CASE													=					IFImgaImgSuperResolutionPipeline(**pipe_a.components				)

								pipe_a.enable_model_cpu_offload()
								pipe_a.enable_model_cpu_offload()

								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)
								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)

								self._test_if_imgaimg(lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__				)

								pipe_a.remove_all_hooks()
								pipe_a.remove_all_hooks()

								# inpainting

								SCREAMING_SNAKE_CASE													=					IFInpaintingPipeline(**pipe_a.components				)
								SCREAMING_SNAKE_CASE													=					IFInpaintingSuperResolutionPipeline(**pipe_a.components				)

								pipe_a.enable_model_cpu_offload()
								pipe_a.enable_model_cpu_offload()

								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)
								pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()				)

								self._test_if_inpainting(lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__				)







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__				)     ->							Tuple:
								# pipeline 1

								_start_torch_memory_measurement()

								SCREAMING_SNAKE_CASE													=					torch.Generator(device='cpu'				).manual_seed(0				)
								SCREAMING_SNAKE_CASE													=					pipe_a(
								    prompt_embeds=lowerCAmelCase__						,       negative_prompt_embeds=lowerCAmelCase__						,       num_inference_steps=2						,       generator=lowerCAmelCase__						,       output_type='np'						,       )

								SCREAMING_SNAKE_CASE													=					output.images[0]

								assert image.shape == (64, 64, 3)

								SCREAMING_SNAKE_CASE													=					torch.cuda.max_memory_allocated()
								assert mem_bytes < 13 * 10**9

								SCREAMING_SNAKE_CASE													=					load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy'				)
								assert_mean_pixel_difference(lowerCAmelCase__						,       lowerCAmelCase__				)

								# pipeline 2

								_start_torch_memory_measurement()

								SCREAMING_SNAKE_CASE													=					torch.Generator(device='cpu'				).manual_seed(0				)

								SCREAMING_SNAKE_CASE													=					floats_tensor((1, 3, 64, 64)						,       rng=random.Random(0				)				).to(lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					pipe_a(
								    prompt_embeds=lowerCAmelCase__						,       negative_prompt_embeds=lowerCAmelCase__						,       image=lowerCAmelCase__						,       generator=lowerCAmelCase__						,       num_inference_steps=2						,       output_type='np'						,       )

								SCREAMING_SNAKE_CASE													=					output.images[0]

								assert image.shape == (256, 256, 3)

								SCREAMING_SNAKE_CASE													=					torch.cuda.max_memory_allocated()
								assert mem_bytes < 4 * 10**9

								SCREAMING_SNAKE_CASE													=					load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'				)
								assert_mean_pixel_difference(lowerCAmelCase__						,       lowerCAmelCase__				)







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__				)     ->							Optional[int]:
								# pipeline 1

								_start_torch_memory_measurement()

								SCREAMING_SNAKE_CASE													=					floats_tensor((1, 3, 64, 64)						,       rng=random.Random(0				)				).to(lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					torch.Generator(device='cpu'				).manual_seed(0				)

								SCREAMING_SNAKE_CASE													=					pipe_a(
								    prompt_embeds=lowerCAmelCase__						,       negative_prompt_embeds=lowerCAmelCase__						,       image=lowerCAmelCase__						,       num_inference_steps=2						,       generator=lowerCAmelCase__						,       output_type='np'						,       )

								SCREAMING_SNAKE_CASE													=					output.images[0]

								assert image.shape == (64, 64, 3)

								SCREAMING_SNAKE_CASE													=					torch.cuda.max_memory_allocated()
								assert mem_bytes < 10 * 10**9

								SCREAMING_SNAKE_CASE													=					load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy'				)
								assert_mean_pixel_difference(lowerCAmelCase__						,       lowerCAmelCase__				)

								# pipeline 2

								_start_torch_memory_measurement()

								SCREAMING_SNAKE_CASE													=					torch.Generator(device='cpu'				).manual_seed(0				)

								SCREAMING_SNAKE_CASE													=					floats_tensor((1, 3, 256, 256)						,       rng=random.Random(0				)				).to(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					floats_tensor((1, 3, 64, 64)						,       rng=random.Random(0				)				).to(lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					pipe_a(
								    prompt_embeds=lowerCAmelCase__						,       negative_prompt_embeds=lowerCAmelCase__						,       image=lowerCAmelCase__						,       original_image=lowerCAmelCase__						,       generator=lowerCAmelCase__						,       num_inference_steps=2						,       output_type='np'						,       )

								SCREAMING_SNAKE_CASE													=					output.images[0]

								assert image.shape == (256, 256, 3)

								SCREAMING_SNAKE_CASE													=					torch.cuda.max_memory_allocated()
								assert mem_bytes < 4 * 10**9

								SCREAMING_SNAKE_CASE													=					load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy'				)
								assert_mean_pixel_difference(lowerCAmelCase__						,       lowerCAmelCase__				)







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__				)     ->							str:
								# pipeline 1

								_start_torch_memory_measurement()

								SCREAMING_SNAKE_CASE													=					floats_tensor((1, 3, 64, 64)						,       rng=random.Random(0				)				).to(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					floats_tensor((1, 3, 64, 64)						,       rng=random.Random(1				)				).to(lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					torch.Generator(device='cpu'				).manual_seed(0				)
								SCREAMING_SNAKE_CASE													=					pipe_a(
								    prompt_embeds=lowerCAmelCase__						,       negative_prompt_embeds=lowerCAmelCase__						,       image=lowerCAmelCase__						,       mask_image=lowerCAmelCase__						,       num_inference_steps=2						,       generator=lowerCAmelCase__						,       output_type='np'						,       )

								SCREAMING_SNAKE_CASE													=					output.images[0]

								assert image.shape == (64, 64, 3)

								SCREAMING_SNAKE_CASE													=					torch.cuda.max_memory_allocated()
								assert mem_bytes < 10 * 10**9

								SCREAMING_SNAKE_CASE													=					load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy'				)
								assert_mean_pixel_difference(lowerCAmelCase__						,       lowerCAmelCase__				)

								# pipeline 2

								_start_torch_memory_measurement()

								SCREAMING_SNAKE_CASE													=					torch.Generator(device='cpu'				).manual_seed(0				)

								SCREAMING_SNAKE_CASE													=					floats_tensor((1, 3, 64, 64)						,       rng=random.Random(0				)				).to(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					floats_tensor((1, 3, 256, 256)						,       rng=random.Random(0				)				).to(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					floats_tensor((1, 3, 256, 256)						,       rng=random.Random(1				)				).to(lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					pipe_a(
								    prompt_embeds=lowerCAmelCase__						,       negative_prompt_embeds=lowerCAmelCase__						,       image=lowerCAmelCase__						,       mask_image=lowerCAmelCase__						,       original_image=lowerCAmelCase__						,       generator=lowerCAmelCase__						,       num_inference_steps=2						,       output_type='np'						,       )

								SCREAMING_SNAKE_CASE													=					output.images[0]

								assert image.shape == (256, 256, 3)

								SCREAMING_SNAKE_CASE													=					torch.cuda.max_memory_allocated()
								assert mem_bytes < 4 * 10**9

								SCREAMING_SNAKE_CASE													=					load_numpy(
								    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy'				)
								assert_mean_pixel_difference(lowerCAmelCase__						,       lowerCAmelCase__				)





def     lowercase			()   ->						Optional[int]:
						torch.cuda.empty_cache()
						torch.cuda.reset_max_memory_allocated()
						torch.cuda.reset_peak_memory_stats()






"""simple docstring"""




# Usage:
# ./gen-card-facebook-wmt19.py

import os
from pathlib import Path


def     lowercase			(SCREAMING_SNAKE_CASE_		:				Tuple ,			SCREAMING_SNAKE_CASE_		:				List[str] ,			SCREAMING_SNAKE_CASE_		:				int  )   ->						List[str]:
						SCREAMING_SNAKE_CASE													=					{
						    'en': 'Machine learning is great, isn\'t it?',
						    'ru': 'Машинное обучение - это здорово, не так ли?',
						    'de': 'Maschinelles Lernen ist großartig, oder?',
						}

						# BLUE scores as follows:
						# "pair": [fairseq, transformers]
						SCREAMING_SNAKE_CASE													=					{
						    'ru-en': ['[41.3](http://matrix.statmt.org/matrix/output/1907?run_id=6937)', '39.20'],
						    'en-ru': ['[36.4](http://matrix.statmt.org/matrix/output/1914?run_id=6724)', '33.47'],
						    'en-de': ['[43.1](http://matrix.statmt.org/matrix/output/1909?run_id=6862)', '42.83'],
						    'de-en': ['[42.3](http://matrix.statmt.org/matrix/output/1902?run_id=6750)', '41.35'],
						}
						SCREAMING_SNAKE_CASE													=					F'{src_lang}-{tgt_lang}'

						SCREAMING_SNAKE_CASE													=					F'\n---\nlanguage: \n- {src_lang}\n- {tgt_lang}\nthumbnail:\ntags:\n- translation\n- wmt19\n- facebook\nlicense: apache-2.0\ndatasets:\n- wmt19\nmetrics:\n- bleu\n---\n\n# FSMT\n\n## Model description\n\nThis is a ported version of [fairseq wmt19 transformer](https://github.com/pytorch/fairseq/blob/master/examples/wmt19/README.md) for {src_lang}-{tgt_lang}.\n\nFor more details, please see, [Facebook FAIR\'s WMT19 News Translation Task Submission](https://arxiv.org/abs/1907.06616).\n\nThe abbreviation FSMT stands for FairSeqMachineTranslation\n\nAll four models are available:\n\n* [wmt19-en-ru](https://huggingface.co/facebook/wmt19-en-ru)\n* [wmt19-ru-en](https://huggingface.co/facebook/wmt19-ru-en)\n* [wmt19-en-de](https://huggingface.co/facebook/wmt19-en-de)\n* [wmt19-de-en](https://huggingface.co/facebook/wmt19-de-en)\n\n## Intended uses & limitations\n\n#### How to use\n\n```python\nfrom transformers import FSMTForConditionalGeneration, FSMTTokenizer\nmname = "facebook/wmt19-{src_lang}-{tgt_lang}"\ntokenizer = FSMTTokenizer.from_pretrained(mname)\nmodel = FSMTForConditionalGeneration.from_pretrained(mname)\n\ninput = "{texts[src_lang]}"\ninput_ids = tokenizer.encode(input, return_tensors="pt")\noutputs = model.generate(input_ids)\ndecoded = tokenizer.decode(outputs[0], skip_special_tokens=True)\nprint(decoded) # {texts[tgt_lang]}\n\n```\n\n#### Limitations and bias\n\n- The original (and this ported model) doesn\'t seem to handle well inputs with repeated sub-phrases, [content gets truncated](https://discuss.huggingface.co/t/issues-with-translating-inputs-containing-repeated-phrases/981)\n\n## Training data\n\nPretrained weights were left identical to the original model released by fairseq. For more details, please, see the [paper](https://arxiv.org/abs/1907.06616).\n\n## Eval results\n\npair   | fairseq | transformers\n-------|---------|----------\n{pair}  | {scores[pair][0]} | {scores[pair][1]}\n\nThe score is slightly below the score reported by `fairseq`, since `transformers`` currently doesn\'t support:\n- model ensemble, therefore the best performing checkpoint was ported (``model4.pt``).\n- re-ranking\n\nThe score was calculated using this code:\n\n```bash\ngit clone https://github.com/huggingface/transformers\ncd transformers\nexport PAIR={pair}\nexport DATA_DIR=data/$PAIR\nexport SAVE_DIR=data/$PAIR\nexport BS=8\nexport NUM_BEAMS=15\nmkdir -p $DATA_DIR\nsacrebleu -t wmt19 -l $PAIR --echo src > $DATA_DIR/val.source\nsacrebleu -t wmt19 -l $PAIR --echo ref > $DATA_DIR/val.target\necho $PAIR\nPYTHONPATH="src:examples/seq2seq" python examples/seq2seq/run_eval.py facebook/wmt19-$PAIR $DATA_DIR/val.source $SAVE_DIR/test_translations.txt --reference_path $DATA_DIR/val.target --score_path $SAVE_DIR/test_bleu.json --bs $BS --task translation --num_beams $NUM_BEAMS\n```\nnote: fairseq reports using a beam of 50, so you should get a slightly higher score if re-run with `--num_beams 50`.\n\n## Data Sources\n\n- [training, etc.](http://www.statmt.org/wmt19/)\n- [test set](http://matrix.statmt.org/test_sets/newstest2019.tgz?1556572561)\n\n\n### BibTeX entry and citation info\n\n```bibtex\n@inproceedings{{...,\n  year={{2020}},\n  title={{Facebook FAIR\'s WMT19 News Translation Task Submission}},\n  author={{Ng, Nathan and Yee, Kyra and Baevski, Alexei and Ott, Myle and Auli, Michael and Edunov, Sergey}},\n  booktitle={{Proc. of WMT}},\n}}\n```\n\n\n## TODO\n\n- port model ensemble (fairseq uses 4 model checkpoints)\n\n'
						os.makedirs(SCREAMING_SNAKE_CASE_ ,			exist_ok=SCREAMING_SNAKE_CASE_  )
						SCREAMING_SNAKE_CASE													=					os.path.join(SCREAMING_SNAKE_CASE_ ,			'README.md'  )
						print(F'Generating {path}'  )
						with open(SCREAMING_SNAKE_CASE_ ,			'w' ,			encoding='utf-8'  ) as f:
												f.write(SCREAMING_SNAKE_CASE_  )


# make sure we are under the root of the project
__UpperCamelCase						=      Path(__file__).resolve().parent.parent.parent
__UpperCamelCase						=      repo_dir / '''model_cards'''

for model_name in ["wmt19-ru-en", "wmt19-en-ru", "wmt19-en-de", "wmt19-de-en"]:
	__UpperCamelCase,__UpperCamelCase,__UpperCamelCase						=      model_name.split('''-''')
	__UpperCamelCase						=      model_cards_dir / '''facebook''' / model_name
	write_model_card(model_card_dir, src_lang=src_lang, tgt_lang=tgt_lang)


