






import numpy as np
from scipy.spatial.distance import cdist
from sklearn.metrics import fa_score

import datasets


UpperCamelCase__     =	"\\n    @inproceedings{kakwani2020indicnlpsuite,\n    title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},\n    author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},\n    year={2020},\n    booktitle={Findings of EMNLP},\n}\n"

UpperCamelCase__     =	"\\n    IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide\n    variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.\n"

UpperCamelCase__     =	"\nCompute IndicGLUE evaluation metric associated to each IndicGLUE dataset.\nArgs:\n    predictions: list of predictions to score (as int64),\n        except for 'cvit-mkb-clsr' where each prediction is a vector (of float32).\n    references: list of ground truth labels corresponding to the predictions (as int64),\n        except for 'cvit-mkb-clsr' where each reference is a vector (of float32).\nReturns: depending on the IndicGLUE subset, one or several of:\n    \"accuracy\": Accuracy\n    \"f1\": F1 score\n    \"precision\": Precision@10\nExamples:\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'wnli')  # 'wnli' or any of [\"copa\", \"sna\", \"csqa\", \"wstp\", \"inltkh\", \"bbca\", \"iitp-mr\", \"iitp-pr\", \"actsa-sc\", \"md\"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'wiki-ner')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0, 'f1': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'cvit-mkb-clsr')\n    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'precision@10': 1.0}\n\n"





def       _UpperCamelCase       (a__				:Optional[Any]				,     a__				:Any    ):






							"""simple docstring"""





							return float((preds == labels).mean()    )





def       _UpperCamelCase       (a__				:Dict				,     a__				:Optional[Any]    ):






							"""simple docstring"""





							UpperCamelCase__			       =     simple_accuracy(a__				,     a__    )
							UpperCamelCase__			       =     float(fa_score(y_true=a__				,     y_pred=a__    )    )
							return {
							    "accuracy": acc,
							    "f1": fa,
							}





def       _UpperCamelCase       (a__				:List[Any]				,     a__				:Any    ):






							"""simple docstring"""





							UpperCamelCase__			       =     np.array(a__    )
							UpperCamelCase__			       =     np.array(a__    )
							UpperCamelCase__			       =     en_sentvecs.shape[0]

							# mean centering
							UpperCamelCase__			       =     en_sentvecs - np.mean(a__				,     axis=0    )
							UpperCamelCase__			       =     in_sentvecs - np.mean(a__				,     axis=0    )

							UpperCamelCase__			       =     cdist(a__				,     a__				,     """cosine"""    )
							UpperCamelCase__			       =     np.array(range(a__    )    )
							UpperCamelCase__			       =     sim.argsort(axis=1    )[:, :10]
							UpperCamelCase__			       =     np.any(preds == actual[:, None]				,     axis=1    )
							return float(matches.mean()    )

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






							def 			_lowerCamelCase						(  self					):
														if self.config_name not in [
														    "wnli",
														    "copa",
														    "sna",
														    "csqa",
														    "wstp",
														    "inltkh",
														    "bbca",
														    "cvit-mkb-clsr",
														    "iitp-mr",
														    "iitp-pr",
														    "actsa-sc",
														    "md",
														    "wiki-ner",
														]:
																					raise KeyError(
																					    """You should supply a configuration name selected in """
																					    """[\"wnli\", \"copa\", \"sna\", \"csqa\", \"wstp\", \"inltkh\", \"bbca\", """
																					    """\"cvit-mkb-clsr\", \"iitp-mr\", \"iitp-pr\", \"actsa-sc\", \"md\", """
																					    """\"wiki-ner\"]"""					)
														return datasets.MetricInfo(
														    description=_DESCRIPTION					,	citation=_CITATION					,	inputs_description=_KWARGS_DESCRIPTION					,	features=datasets.Features(
														        {
														            """predictions""": datasets.Value("""int64"""					)
														            if self.config_name != """cvit-mkb-clsr"""
														            else datasets.Sequence(datasets.Value("""float32"""					)					),
														            """references""": datasets.Value("""int64"""					)
														            if self.config_name != """cvit-mkb-clsr"""
														            else datasets.Sequence(datasets.Value("""float32"""					)					),
														        }					)					,	codebase_urls=[]					,	reference_urls=[]					,	format="""numpy""" if self.config_name != """cvit-mkb-clsr""" else None					,	)







							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					):
														if self.config_name == "cvit-mkb-clsr":
																					return {"precision@10": precision_at_aa(__lowerCAmelCase					,	__lowerCAmelCase					)}
														elif self.config_name in ["wiki-ner"]:
																					return acc_and_fa(__lowerCAmelCase					,	__lowerCAmelCase					)
														elif self.config_name in [
														    "wnli",
														    "copa",
														    "sna",
														    "csqa",
														    "wstp",
														    "inltkh",
														    "bbca",
														    "iitp-mr",
														    "iitp-pr",
														    "actsa-sc",
														    "md",
														]:
																					return {"accuracy": simple_accuracy(__lowerCAmelCase					,	__lowerCAmelCase					)}
														else:
																					raise KeyError(
																					    """You should supply a configuration name selected in """
																					    """[\"wnli\", \"copa\", \"sna\", \"csqa\", \"wstp\", \"inltkh\", \"bbca\", """
																					    """\"cvit-mkb-clsr\", \"iitp-mr\", \"iitp-pr\", \"actsa-sc\", \"md\", """
																					    """\"wiki-ner\"]"""					)











import unittest

from parameterized import parameterized

from transformers import AutoTokenizer, GPTNeoXConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    GPTNeoXForCausalLM,
					    GPTNeoXForQuestionAnswering,
					    GPTNeoXForSequenceClassification,
					    GPTNeoXForTokenClassification,
					    GPTNeoXModel,
					)

class     __SCREAMING_SNAKE_CASE   :






							def __init__(  self					,	__lowerCAmelCase					,	__lowerCAmelCase=13					,	__lowerCAmelCase=7					,	__lowerCAmelCase=True					,	__lowerCAmelCase=True					,	__lowerCAmelCase=True					,	__lowerCAmelCase=True					,	__lowerCAmelCase=99					,	__lowerCAmelCase=64					,	__lowerCAmelCase=5					,	__lowerCAmelCase=4					,	__lowerCAmelCase=37					,	__lowerCAmelCase="gelu"					,	__lowerCAmelCase=0.1					,	__lowerCAmelCase=0.1					,	__lowerCAmelCase=512					,	__lowerCAmelCase=16					,	__lowerCAmelCase=2					,	__lowerCAmelCase=0.02					,	__lowerCAmelCase=3					,	__lowerCAmelCase=4					,	__lowerCAmelCase=None					,	):
														UpperCamelCase__			       =     parent
														UpperCamelCase__			       =     batch_size
														UpperCamelCase__			       =     seq_length
														UpperCamelCase__			       =     is_training
														UpperCamelCase__			       =     use_input_mask
														UpperCamelCase__			       =     use_token_type_ids
														UpperCamelCase__			       =     use_labels
														UpperCamelCase__			       =     vocab_size
														UpperCamelCase__			       =     hidden_size
														UpperCamelCase__			       =     num_hidden_layers
														UpperCamelCase__			       =     num_attention_heads
														UpperCamelCase__			       =     intermediate_size
														UpperCamelCase__			       =     hidden_act
														UpperCamelCase__			       =     hidden_dropout_prob
														UpperCamelCase__			       =     attention_probs_dropout_prob
														UpperCamelCase__			       =     max_position_embeddings
														UpperCamelCase__			       =     type_vocab_size
														UpperCamelCase__			       =     type_sequence_label_size
														UpperCamelCase__			       =     initializer_range
														UpperCamelCase__			       =     num_labels
														UpperCamelCase__			       =     num_choices
														UpperCamelCase__			       =     scope
														UpperCamelCase__			       =     vocab_size - 1






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     ids_tensor([self.batch_size, self.seq_length]					,	self.vocab_size					)

														UpperCamelCase__			       =     None
														if self.use_input_mask:
																					UpperCamelCase__			       =     random_attention_mask([self.batch_size, self.seq_length]					)

														UpperCamelCase__			       =     None
														if self.use_labels:
																					UpperCamelCase__			       =     ids_tensor([self.batch_size, self.seq_length]					,	self.num_labels					)

														UpperCamelCase__			       =     self.get_config()

														return config, input_ids, input_mask, token_labels






							def 			_lowerCamelCase						(  self					):
														return GPTNeoXConfig(
														    vocab_size=self.vocab_size					,	hidden_size=self.hidden_size					,	num_hidden_layers=self.num_hidden_layers					,	num_attention_heads=self.num_attention_heads					,	intermediate_size=self.intermediate_size					,	hidden_act=self.hidden_act					,	hidden_dropout_prob=self.hidden_dropout_prob					,	attention_probs_dropout_prob=self.attention_probs_dropout_prob					,	max_position_embeddings=self.max_position_embeddings					,	type_vocab_size=self.type_vocab_size					,	is_decoder=__lowerCAmelCase					,	initializer_range=self.initializer_range					,	pad_token_id=self.pad_token_id					,	)






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__			       =     self.prepare_config_and_inputs()

														UpperCamelCase__			       =     True

														return config, input_ids, input_mask, token_labels






							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					):
														UpperCamelCase__			       =     GPTNeoXModel(config=__lowerCAmelCase					)
														model.to(__lowerCAmelCase					)
														model.eval()
														UpperCamelCase__			       =     model(__lowerCAmelCase					,	attention_mask=__lowerCAmelCase					)
														UpperCamelCase__			       =     model(__lowerCAmelCase					)
														self.parent.assertEqual(result.last_hidden_state.shape					,	(self.batch_size, self.seq_length, self.hidden_size)					)






							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					):
														UpperCamelCase__			       =     True
														UpperCamelCase__			       =     GPTNeoXModel(__lowerCAmelCase					)
														model.to(__lowerCAmelCase					)
														model.eval()
														UpperCamelCase__			       =     model(__lowerCAmelCase					,	attention_mask=__lowerCAmelCase					)
														self.parent.assertEqual(result.last_hidden_state.shape					,	(self.batch_size, self.seq_length, self.hidden_size)					)






							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					):
														UpperCamelCase__			       =     GPTNeoXForCausalLM(config=__lowerCAmelCase					)
														model.to(__lowerCAmelCase					)
														model.eval()
														UpperCamelCase__			       =     model(__lowerCAmelCase					,	attention_mask=__lowerCAmelCase					,	labels=__lowerCAmelCase					)
														self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.seq_length, self.vocab_size)					)






							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					):
														UpperCamelCase__			       =     self.num_labels
														UpperCamelCase__			       =     GPTNeoXForQuestionAnswering(__lowerCAmelCase					)
														model.to(__lowerCAmelCase					)
														model.eval()
														UpperCamelCase__			       =     model(__lowerCAmelCase					,	attention_mask=__lowerCAmelCase					)
														self.parent.assertEqual(result.start_logits.shape					,	(self.batch_size, self.seq_length)					)
														self.parent.assertEqual(result.end_logits.shape					,	(self.batch_size, self.seq_length)					)






							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					):
														UpperCamelCase__			       =     self.num_labels
														UpperCamelCase__			       =     GPTNeoXForSequenceClassification(__lowerCAmelCase					)
														model.to(__lowerCAmelCase					)
														model.eval()
														UpperCamelCase__			       =     ids_tensor([self.batch_size]					,	self.type_sequence_label_size					)
														UpperCamelCase__			       =     model(__lowerCAmelCase					,	attention_mask=__lowerCAmelCase					,	labels=__lowerCAmelCase					)
														self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.num_labels)					)






							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					):
														UpperCamelCase__			       =     self.num_labels
														UpperCamelCase__			       =     GPTNeoXForTokenClassification(__lowerCAmelCase					)
														model.to(__lowerCAmelCase					)
														model.eval()
														UpperCamelCase__			       =     model(__lowerCAmelCase					,	attention_mask=__lowerCAmelCase					,	labels=__lowerCAmelCase					)
														self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.seq_length, self.num_labels)					)






							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					):
														UpperCamelCase__			       =     True
														UpperCamelCase__			       =     GPTNeoXForCausalLM(config=__lowerCAmelCase					)
														model.to(__lowerCAmelCase					)
														model.eval()

														# first forward pass
														UpperCamelCase__			       =     model(__lowerCAmelCase					,	attention_mask=__lowerCAmelCase					,	use_cache=__lowerCAmelCase					)
														UpperCamelCase__			       =     outputs.past_key_values

														# create hypothetical multiple next token and extent to next_input_ids
														UpperCamelCase__			       =     ids_tensor((self.batch_size, 3)					,	config.vocab_size					)
														UpperCamelCase__			       =     ids_tensor((self.batch_size, 3)					,	vocab_size=2					)

														# append to next input_ids and
														UpperCamelCase__			       =     torch.cat([input_ids, next_tokens]					,	dim=-1					)
														UpperCamelCase__			       =     torch.cat([input_mask, next_mask]					,	dim=-1					)

														UpperCamelCase__			       =     model(__lowerCAmelCase					,	attention_mask=__lowerCAmelCase					,	output_hidden_states=__lowerCAmelCase					)
														UpperCamelCase__			       =     output_from_no_past["""hidden_states"""][0]
														UpperCamelCase__			       =     model(
														    __lowerCAmelCase					,	attention_mask=__lowerCAmelCase					,	past_key_values=__lowerCAmelCase					,	output_hidden_states=__lowerCAmelCase					,	)["""hidden_states"""][0]

														# select random slice
														UpperCamelCase__			       =     ids_tensor((1,)					,	output_from_past.shape[-1]					).item()
														UpperCamelCase__			       =     output_from_no_past[:, -3:, random_slice_idx].detach()
														UpperCamelCase__			       =     output_from_past[:, :, random_slice_idx].detach()

														self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]					)

														# test that outputs are equal for slice
														self.parent.assertTrue(torch.allclose(__lowerCAmelCase					,	__lowerCAmelCase					,	atol=1E-3					)					)







							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     self.prepare_config_and_inputs()
														UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__			       =     config_and_inputs
														UpperCamelCase__			       =     {"""input_ids""": input_ids, """attention_mask""": input_mask}
														return config, inputs_dict






@require_torch
class     __SCREAMING_SNAKE_CASE   (       _a				,						_a				,						_a				,						unittest.TestCase    ):
							snake_case       : Optional[Any]         =    (
							    (
							        GPTNeoXModel,
							        GPTNeoXForCausalLM,
							        GPTNeoXForQuestionAnswering,
							        GPTNeoXForSequenceClassification,
							        GPTNeoXForTokenClassification,
							    )
							    if is_torch_available()
							    else ()
							)
							snake_case       : Union[str, Any]         =    (GPTNeoXForCausalLM,) if is_torch_available() else ()
							snake_case       : Dict         =    (
							    {
							        """feature-extraction""": GPTNeoXModel,
							        """question-answering""": GPTNeoXForQuestionAnswering,
							        """text-classification""": GPTNeoXForSequenceClassification,
							        """text-generation""": GPTNeoXForCausalLM,
							        """token-classification""": GPTNeoXForTokenClassification,
							        """zero-shot""": GPTNeoXForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							snake_case       : Tuple         =    False
							snake_case       : Dict         =    False
							snake_case       : Tuple         =    False
							snake_case       : Any         =    False






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     GPTNeoXModelTester(self					)
														UpperCamelCase__			       =     ConfigTester(self					,	config_class=__lowerCAmelCase					,	hidden_size=64					,	num_attention_heads=8					)






							def 			_lowerCamelCase						(  self					):
														self.config_tester.run_common_tests()






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs_for_decoder()
														self.model_tester.create_and_check_model_as_decoder(__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
														# This regression test was failing with PyTorch < 1.3
														UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs_for_decoder()

														UpperCamelCase__			       =     None

														self.model_tester.create_and_check_model_as_decoder(__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_decoder_model_past_large_inputs(__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_causal_lm(*__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_question_answering(*__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_sequence_classification(*__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_token_classification(*__lowerCAmelCase					)






							@unittest.skip(reason="""Feed forward chunking is not implemented"""					)
							def 			_lowerCamelCase						(  self					):
														pass







							@parameterized.expand([("""linear""",), ("""dynamic""",)]					)
							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					):
														UpperCamelCase__       ,       UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs_for_common()
														UpperCamelCase__			       =     ids_tensor([1, 10]					,	config.vocab_size					)
														UpperCamelCase__			       =     ids_tensor([1, int(config.max_position_embeddings * 1.5					)]					,	config.vocab_size					)

														set_seed(42					)  # Fixed seed at init time so the two models get the same random weights
														UpperCamelCase__			       =     GPTNeoXModel(__lowerCAmelCase					)
														original_model.to(__lowerCAmelCase					)
														original_model.eval()
														UpperCamelCase__			       =     original_model(__lowerCAmelCase					).last_hidden_state
														UpperCamelCase__			       =     original_model(__lowerCAmelCase					).last_hidden_state

														set_seed(42					)  # Fixed seed at init time so the two models get the same random weights
														UpperCamelCase__			       =     {"""type""": scaling_type, """factor""": 10.0}
														UpperCamelCase__			       =     GPTNeoXModel(__lowerCAmelCase					)
														scaled_model.to(__lowerCAmelCase					)
														scaled_model.eval()
														UpperCamelCase__			       =     scaled_model(__lowerCAmelCase					).last_hidden_state
														UpperCamelCase__			       =     scaled_model(__lowerCAmelCase					).last_hidden_state

														# Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
														# maximum sequence length, so the outputs for the short input should match.
														if scaling_type == "dynamic":
																					self.assertTrue(torch.allclose(__lowerCAmelCase					,	__lowerCAmelCase					,	atol=1E-5					)					)
														else:
																					self.assertFalse(torch.allclose(__lowerCAmelCase					,	__lowerCAmelCase					,	atol=1E-5					)					)

														# The output should be different for long inputs
														self.assertFalse(torch.allclose(__lowerCAmelCase					,	__lowerCAmelCase					,	atol=1E-5					)					)






@require_torch
class     __SCREAMING_SNAKE_CASE   (       unittest.TestCase    ):






							@slow
							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     AutoTokenizer.from_pretrained("""EleutherAI/pythia-410m-deduped"""					)
														for checkpointing in [True, False]:
																					UpperCamelCase__			       =     GPTNeoXForCausalLM.from_pretrained("""EleutherAI/pythia-410m-deduped"""					)

																					if checkpointing:
																												model.gradient_checkpointing_enable()
																					else:
																												model.gradient_checkpointing_disable()
																					model.to(__lowerCAmelCase					)

																					UpperCamelCase__			       =     tokenizer("""My favorite food is"""					,	return_tensors="""pt"""					).to(__lowerCAmelCase					)
																					# The hub repo. is updated on 2023-04-04, resulting in poor outputs.
																					# See: https://github.com/huggingface/transformers/pull/24193
																					UpperCamelCase__			       =     """My favorite food is a good old-fashioned, old-fashioned, old-fashioned.\n\nI'm not sure"""

																					UpperCamelCase__			       =     model.generate(**__lowerCAmelCase					,	do_sample=__lowerCAmelCase					,	max_new_tokens=20					)
																					UpperCamelCase__			       =     tokenizer.batch_decode(__lowerCAmelCase					)[0]

																					self.assertEqual(__lowerCAmelCase					,	__lowerCAmelCase					)




