





"""simple docstring"""





import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY





@is_pipeline_test
@require_torch_or_tf
class        _lowerCamelCase      (       unittest.TestCase ):
						UpperCAmelCase_ =			MODEL_FOR_CAUSAL_LM_MAPPING
						UpperCAmelCase_ =			TF_MODEL_FOR_CAUSAL_LM_MAPPING


						@require_torch
						def     snake_case_   (self		) ->   Union[str, Any]:
								UpperCamelCase   =	pipeline(task="text-generation"   ,							model="sshleifer/tiny-ctrl"   ,							framework="pt"		)
								# Using `do_sample=False` to force deterministic output
								UpperCamelCase   =	text_generator("This is a test"   ,							do_sample=__a		)
								self.assertEqual(
								    __a   ,							[
								        {
								            "generated_text": (
								                "This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
								                " oscope. FiliFili@@"
								            )
								        }
								    ]   ,							)

								UpperCamelCase   =	text_generator(["This is a test", "This is a second test"]		)
								self.assertEqual(
								    __a   ,							[
								        [
								            {
								                "generated_text": (
								                    "This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."
								                    " oscope. FiliFili@@"
								                )
								            }
								        ],
								        [
								            {
								                "generated_text": (
								                    "This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy"
								                    " oscope. oscope. FiliFili@@"
								                )
								            }
								        ],
								    ]   ,							)

								UpperCamelCase   =	text_generator("This is a test"   ,							do_sample=__a   ,							num_return_sequences=2   ,							return_tensors=__a		)
								self.assertEqual(
								    __a   ,							[
								        {"generated_token_ids": ANY(__a		)},
								        {"generated_token_ids": ANY(__a		)},
								    ]   ,							)
								UpperCamelCase   =	text_generator.model.config.eos_token_id
								UpperCamelCase   =	"<pad>"
								UpperCamelCase   =	text_generator(
								    ["This is a test", "This is a second test"]   ,							do_sample=__a   ,							num_return_sequences=2   ,							batch_size=2   ,							return_tensors=__a   ,							)
								self.assertEqual(
								    __a   ,							[
								        [
								            {"generated_token_ids": ANY(__a		)},
								            {"generated_token_ids": ANY(__a		)},
								        ],
								        [
								            {"generated_token_ids": ANY(__a		)},
								            {"generated_token_ids": ANY(__a		)},
								        ],
								    ]   ,							)


						@require_tf
						def     snake_case_   (self		) ->   int:
								UpperCamelCase   =	pipeline(task="text-generation"   ,							model="sshleifer/tiny-ctrl"   ,							framework="tf"		)

								# Using `do_sample=False` to force deterministic output
								UpperCamelCase   =	text_generator("This is a test"   ,							do_sample=__a		)
								self.assertEqual(
								    __a   ,							[
								        {
								            "generated_text": (
								                "This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"
								                " please,"
								            )
								        }
								    ]   ,							)

								UpperCamelCase   =	text_generator(["This is a test", "This is a second test"]   ,							do_sample=__a		)
								self.assertEqual(
								    __a   ,							[
								        [
								            {
								                "generated_text": (
								                    "This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"
								                    " please,"
								                )
								            }
								        ],
								        [
								            {
								                "generated_text": (
								                    "This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes"
								                    " Cannes 閲閲Cannes Cannes Cannes 攵 please,"
								                )
								            }
								        ],
								    ]   ,							)


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a		) ->   str:
								UpperCamelCase   =	TextGenerationPipeline(model=__a   ,							tokenizer=__a		)
								return text_generator, ["This is a test", "Another test"]


						def     snake_case_   (self		) ->   Dict:
								UpperCamelCase   =	"Hello I believe in"
								UpperCamelCase   =	pipeline("text-generation"   ,							model="hf-internal-testing/tiny-random-gpt2"		)
								UpperCamelCase   =	text_generator(__a		)
								self.assertEqual(
								    __a   ,							[{"generated_text": "Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"}]   ,							)

								UpperCamelCase   =	text_generator(__a   ,							stop_sequence=" fe"		)
								self.assertEqual(__a   ,							[{"generated_text": "Hello I believe in fe"}]		)


						def     snake_case_   (self   ,							__a   ,							__a		) ->   Dict:
								UpperCamelCase   =	text_generator.model
								UpperCamelCase   =	text_generator.tokenizer

								UpperCamelCase   =	text_generator("This is a test"		)
								self.assertEqual(__a   ,							[{"generated_text": ANY(__a		)}]		)
								self.assertTrue(outputs[0]["generated_text"].startswith("This is a test"		)		)

								UpperCamelCase   =	text_generator("This is a test"   ,							return_full_text=__a		)
								self.assertEqual(__a   ,							[{"generated_text": ANY(__a		)}]		)
								self.assertNotIn("This is a test"   ,							outputs[0]["generated_text"]		)

								UpperCamelCase   =	pipeline(task="text-generation"   ,							model=__a   ,							tokenizer=__a   ,							return_full_text=__a		)
								UpperCamelCase   =	text_generator("This is a test"		)
								self.assertEqual(__a   ,							[{"generated_text": ANY(__a		)}]		)
								self.assertNotIn("This is a test"   ,							outputs[0]["generated_text"]		)

								UpperCamelCase   =	text_generator("This is a test"   ,							return_full_text=__a		)
								self.assertEqual(__a   ,							[{"generated_text": ANY(__a		)}]		)
								self.assertTrue(outputs[0]["generated_text"].startswith("This is a test"		)		)

								UpperCamelCase   =	text_generator(["This is great !", "Something else"]   ,							num_return_sequences=2   ,							do_sample=__a		)
								self.assertEqual(
								    __a   ,							[
								        [{"generated_text": ANY(__a		)}, {"generated_text": ANY(__a		)}],
								        [{"generated_text": ANY(__a		)}, {"generated_text": ANY(__a		)}],
								    ]   ,							)

								if text_generator.tokenizer.pad_token is not None:
										UpperCamelCase   =	text_generator(
										    ["This is great !", "Something else"]   ,							num_return_sequences=2   ,							batch_size=2   ,							do_sample=__a		)
										self.assertEqual(
										    __a   ,							[
										        [{"generated_text": ANY(__a		)}, {"generated_text": ANY(__a		)}],
										        [{"generated_text": ANY(__a		)}, {"generated_text": ANY(__a		)}],
										    ]   ,							)

								with self.assertRaises(__a		):
										UpperCamelCase   =	text_generator("test"   ,							return_full_text=__a   ,							return_text=__a		)
								with self.assertRaises(__a		):
										UpperCamelCase   =	text_generator("test"   ,							return_full_text=__a   ,							return_tensors=__a		)
								with self.assertRaises(__a		):
										UpperCamelCase   =	text_generator("test"   ,							return_text=__a   ,							return_tensors=__a		)

								# Empty prompt is slighly special
								# it requires BOS token to exist.
								# Special case for Pegasus which will always append EOS so will
								# work even without BOS.
								if (
								    text_generator.tokenizer.bos_token_id is not None
								    or "Pegasus" in tokenizer.__class__.__name__
								    or "Git" in model.__class__.__name__
								):
										UpperCamelCase   =	text_generator(""		)
										self.assertEqual(__a   ,							[{"generated_text": ANY(__a		)}]		)
								else:
										with self.assertRaises((ValueError, AssertionError)		):
												UpperCamelCase   =	text_generator(""		)

								if text_generator.framework == "tf":
										# TF generation does not support max_new_tokens, and it's impossible
										# to control long generation with only max_length without
										# fancy calculation, dismissing tests for now.
										return
								# We don't care about infinite range models.
								# They already work.
								# Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
								UpperCamelCase   =	["RwkvForCausalLM", "XGLMForCausalLM", "GPTNeoXForCausalLM"]
								if (
								    tokenizer.model_max_length < 1_00_00
								    and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
								):
										# Handling of large generations
										with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)		):
												text_generator("This is a test" * 5_00   ,							max_new_tokens=20		)

										UpperCamelCase   =	text_generator("This is a test" * 5_00   ,							handle_long_generation="hole"   ,							max_new_tokens=20		)
										# Hole strategy cannot work
										with self.assertRaises(__a		):
												text_generator(
												    "This is a test" * 5_00   ,							handle_long_generation="hole"   ,							max_new_tokens=tokenizer.model_max_length + 10   ,							)


						@require_torch
						@require_accelerate
						@require_torch_gpu
						def     snake_case_   (self		) ->   int:
								import torch

								# Classic `model_kwargs`
								UpperCamelCase   =	pipeline(
								    model="hf-internal-testing/tiny-random-bloom"   ,							model_kwargs={"device_map": "auto", "torch_dtype": torch.bfloataa}   ,							)
								self.assertEqual(pipe.model.device   ,							torch.device(0		)		)
								self.assertEqual(pipe.model.lm_head.weight.dtype   ,							torch.bfloataa		)
								UpperCamelCase   =	pipe("This is a test"		)
								self.assertEqual(
								    __a   ,							[
								        {
								            "generated_text": (
								                "This is a test test test test test test test test test test test test test test test test"
								                " test"
								            )
								        }
								    ]   ,							)

								# Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
								UpperCamelCase   =	pipeline(model="hf-internal-testing/tiny-random-bloom"   ,							device_map="auto"   ,							torch_dtype=torch.bfloataa		)
								self.assertEqual(pipe.model.device   ,							torch.device(0		)		)
								self.assertEqual(pipe.model.lm_head.weight.dtype   ,							torch.bfloataa		)
								UpperCamelCase   =	pipe("This is a test"		)
								self.assertEqual(
								    __a   ,							[
								        {
								            "generated_text": (
								                "This is a test test test test test test test test test test test test test test test test"
								                " test"
								            )
								        }
								    ]   ,							)

								# torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
								UpperCamelCase   =	pipeline(model="hf-internal-testing/tiny-random-bloom"   ,							device_map="auto"		)
								self.assertEqual(pipe.model.device   ,							torch.device(0		)		)
								self.assertEqual(pipe.model.lm_head.weight.dtype   ,							torch.floataa		)
								UpperCamelCase   =	pipe("This is a test"		)
								self.assertEqual(
								    __a   ,							[
								        {
								            "generated_text": (
								                "This is a test test test test test test test test test test test test test test test test"
								                " test"
								            )
								        }
								    ]   ,							)


						@require_torch
						@require_torch_gpu
						def     snake_case_   (self		) ->   List[str]:
								import torch

								UpperCamelCase   =	pipeline(model="hf-internal-testing/tiny-random-bloom"   ,							device=0   ,							torch_dtype=torch.floataa		)
								pipe("This is a test"		)


						@require_torch
						@require_accelerate
						@require_torch_gpu
						def     snake_case_   (self		) ->   int:
								import torch

								UpperCamelCase   =	pipeline(model="hf-internal-testing/tiny-random-bloom"   ,							device_map="auto"   ,							torch_dtype=torch.floataa		)
								pipe("This is a test"   ,							do_sample=__a   ,							top_p=0.5		)




						def     snake_case_   (self		) ->   List[str]:
								UpperCamelCase   =	"Hello world"
								UpperCamelCase   =	pipeline("text-generation"   ,							model="hf-internal-testing/tiny-random-gpt2"		)
								if text_generator.model.framework == "tf":
										UpperCamelCase   =	logging.get_logger("transformers.generation.tf_utils"		)
								else:
										UpperCamelCase   =	logging.get_logger("transformers.generation.utils"		)
								UpperCamelCase   =	"Both `max_new_tokens`"  # The beggining of the message to be checked in this test

								# Both are set by the user -> log warning
								with CaptureLogger(__a		) as cl:
										UpperCamelCase   =	text_generator(__a   ,							max_length=10   ,							max_new_tokens=1		)
								self.assertIn(__a   ,							cl.out		)

								# The user only sets one -> no warning
								with CaptureLogger(__a		) as cl:
										UpperCamelCase   =	text_generator(__a   ,							max_new_tokens=1		)
								self.assertNotIn(__a   ,							cl.out		)

								with CaptureLogger(__a		) as cl:
										UpperCamelCase   =	text_generator(__a   ,							max_length=10		)
								self.assertNotIn(__a   ,							cl.out		)











"""simple docstring"""





import argparse

import torch
from torch import nn

from transformers import MaMaaaConfig, MaMaaaForConditionalGeneration


def       a__					(					_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		UpperCamelCase   =	[
		    "encoder.version",
		    "decoder.version",
		    "model.encoder.version",
		    "model.decoder.version",
		    "decoder.output_projection.weight",
		    "_float_tensor",
		    "encoder.embed_positions._float_tensor",
		    "decoder.embed_positions._float_tensor",
		]
		for k in ignore_keys:
				state_dict.pop(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    )


def       a__					(					_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		UpperCamelCase   ,				UpperCamelCase   =	emb.weight.shape
		UpperCamelCase   =	nn.Linear(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	bias=_SCREAMING_SNAKE_CASE    )
		UpperCamelCase   =	emb.weight.data
		return lin_layer


def       a__					(					_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		UpperCamelCase   =	torch.load(_SCREAMING_SNAKE_CASE  ,	map_location="cpu"    )
		UpperCamelCase   =	mam_aaa["args"] or mam_aaa["cfg"]["model"]
		UpperCamelCase   =	mam_aaa["model"]
		remove_ignore_keys_(_SCREAMING_SNAKE_CASE    )
		UpperCamelCase   =	state_dict["encoder.embed_tokens.weight"].shape[0]

		UpperCamelCase   =	MaMaaaConfig(
		    vocab_size=_SCREAMING_SNAKE_CASE  ,	max_position_embeddings=1_024  ,	encoder_layers=args.encoder_layers  ,	decoder_layers=args.decoder_layers  ,	encoder_attention_heads=args.encoder_attention_heads  ,	decoder_attention_heads=args.decoder_attention_heads  ,	encoder_ffn_dim=args.encoder_ffn_embed_dim  ,	decoder_ffn_dim=args.decoder_ffn_embed_dim  ,	d_model=args.encoder_embed_dim  ,	encoder_layerdrop=args.encoder_layerdrop  ,	decoder_layerdrop=args.decoder_layerdrop  ,	dropout=args.dropout  ,	attention_dropout=args.attention_dropout  ,	activation_dropout=args.activation_dropout  ,	activation_function="relu"  ,	)

		UpperCamelCase   =	state_dict["decoder.embed_tokens.weight"]
		UpperCamelCase   =	MaMaaaForConditionalGeneration(_SCREAMING_SNAKE_CASE    )
		model.model.load_state_dict(_SCREAMING_SNAKE_CASE  ,	strict=_SCREAMING_SNAKE_CASE    )
		UpperCamelCase   =	make_linear_from_emb(model.model.shared    )

		return model


if __name__ == "__main__":
						lowerCAmelCase__     			=			argparse.ArgumentParser()
						# Required parameters
						parser.add_argument('''fairseq_path''', type=str, help='''path to a model.pt on local filesystem.''')
						parser.add_argument('''pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
						lowerCAmelCase__     			=			parser.parse_args()
						lowerCAmelCase__     			=			convert_fairseq_mamaaa_checkpoint_from_disk(args.fairseq_pathß)
						model.save_pretrained(args.pytorch_dump_folder_path)






