





import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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 (
     NystromformerForMaskedLM,
     NystromformerForMultipleChoice,
     NystromformerForQuestionAnswering,
     NystromformerForSequenceClassification,
     NystromformerForTokenClassification,
     NystromformerModel,
 )
 from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST







class      lowerCamelCase:
     '''simple docstring'''


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




     def        lowerCAmelCase__		(    self							):
         _A     =							ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size							)

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

         _A     =							None
         if self.use_token_type_ids:
             _A     =							ids_tensor([self.batch_size, self.seq_length]				,     self.type_vocab_size							)

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

         _A     =							self.get_config()

         return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




     def        lowerCAmelCase__		(    self							):
         return NystromformerConfig(
             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=snake_case_				,     initializer_range=self.initializer_range				,     )




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							NystromformerModel(config=snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							model(snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_							)
         _A     =							model(snake_case_				,     token_type_ids=snake_case_							)
         _A     =							model(snake_case_							)
         self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size)							)




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							NystromformerForMaskedLM(config=snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							model(snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_				,     labels=snake_case_							)
         self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.vocab_size)							)




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							NystromformerForQuestionAnswering(config=snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							model(
             snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_				,     start_positions=snake_case_				,     end_positions=snake_case_				,     )
         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				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							self.num_labels
         _A     =							NystromformerForSequenceClassification(snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							model(snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_				,     labels=snake_case_							)
         self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)							)




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							self.num_labels
         _A     =							NystromformerForTokenClassification(config=snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							model(snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_				,     labels=snake_case_							)
         self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.num_labels)							)




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							self.num_choices
         _A     =							NystromformerForMultipleChoice(config=snake_case_							)
         model.to(snake_case_							)
         model.eval()
         _A     =							input_ids.unsqueeze(1							).expand(-1				,     self.num_choices				,     -1							).contiguous()
         _A     =							token_type_ids.unsqueeze(1							).expand(-1				,     self.num_choices				,     -1							).contiguous()
         _A     =							input_mask.unsqueeze(1							).expand(-1				,     self.num_choices				,     -1							).contiguous()
         _A     =							model(
             snake_case_				,     attention_mask=snake_case_				,     token_type_ids=snake_case_				,     labels=snake_case_				,     )
         self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_choices)							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.prepare_config_and_inputs()
         (
             (
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			(
             _A
         ),			
         )     =							config_and_inputs
         _A     =							{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
         return config, inputs_dict







@require_torch
class      lowerCamelCase(						__snake_case			, __snake_case			, unittest.TestCase	):
     '''simple docstring'''


     __magic_name__   =			(
         (
             NystromformerModel,
             NystromformerForMaskedLM,
             NystromformerForMultipleChoice,
             NystromformerForQuestionAnswering,
             NystromformerForSequenceClassification,
             NystromformerForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     __magic_name__   =			(
         {
             'feature-extraction': NystromformerModel,
             'fill-mask': NystromformerForMaskedLM,
             'question-answering': NystromformerForQuestionAnswering,
             'text-classification': NystromformerForSequenceClassification,
             'token-classification': NystromformerForTokenClassification,
             'zero-shot': NystromformerForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     __magic_name__   =			False
     __magic_name__   =			False




     def        lowerCAmelCase__		(    self							):
         _A     =							NystromformerModelTester(self							)
         _A     =							ConfigTester(self				,     config_class=snake_case_				,     hidden_size=37							)




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




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
             _A     =							type
             self.model_tester.create_and_check_model(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*snake_case_							)




     @slow
     def        lowerCAmelCase__		(    self							):
         for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _A     =							NystromformerModel.from_pretrained(snake_case_							)
             self.assertIsNotNone(snake_case_							)







@require_torch
class      lowerCamelCase(						unittest.TestCase	):
     '''simple docstring'''


     @slow
     def        lowerCAmelCase__		(    self							):
         _A     =							NystromformerModel.from_pretrained('uw-madison/nystromformer-512'							)
         _A     =							torch.tensor([[0, 1, 2, 3, 4, 5]]							)

         with torch.no_grad():
             _A     =							model(snake_case_							)[0]

         _A     =							torch.Size((1, 6, 768)							)
         self.assertEqual(output.shape				,     snake_case_							)

         _A     =							torch.tensor(
             [[[-0.4532, -0.0936, 0.5137], [-0.2676, 0.0628, 0.6186], [-0.3629, -0.1726, 0.4716]]]							)

         self.assertTrue(torch.allclose(output[:, :3, :3]				,     snake_case_				,     atol=1E-4							)							)




     @slow
     def        lowerCAmelCase__		(    self							):
         _A     =							'the [MASK] of Belgium is Brussels'

         _A     =							AutoTokenizer.from_pretrained('uw-madison/nystromformer-512'							)
         _A     =							NystromformerForMaskedLM.from_pretrained('uw-madison/nystromformer-512'							)

         _A     =							tokenizer(snake_case_				,     return_tensors='pt'							)

         with torch.no_grad():
             _A     =							model(encoding.input_ids							).logits

         _A     =							token_logits[:, 2, :].argmax(-1							)[0]

         self.assertEqual(tokenizer.decode(snake_case_							)				,     'capital'							)






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  UpperCamelCase_						(   self      :     str		):
												_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  UpperCamelCase_						(   self      :     Dict		):
												_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  UpperCamelCase_						(   self      :     int ,			_A      :     str ,			_A      :     Union[str, Any] ,			_A      :     Any		):
												_UpperCamelCase			     =     TextGenerationPipeline(model=_A ,			tokenizer=_A		)
												return text_generator, ["This is a test", "Another test"]







							def  UpperCamelCase_						(   self      :     Union[str, Any]		):
												_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  UpperCamelCase_						(   self      :     Any ,			_A      :     List[Any] ,			_A      :     Union[str, Any]		):
												_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_0000
												    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''' * 500 ,			max_new_tokens=20		)

																	_UpperCamelCase			     =     text_generator('''This is a test''' * 500 ,			handle_long_generation='''hole''' ,			max_new_tokens=20		)
																	# Hole strategy cannot work
																	with self.assertRaises(_A		):
																						text_generator(
																						    '''This is a test''' * 500 ,			handle_long_generation='''hole''' ,			max_new_tokens=tokenizer.model_max_length + 10 ,			)







							@require_torch
							@require_accelerate
							@require_torch_gpu
							def  UpperCamelCase_						(   self      :     Optional[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  UpperCamelCase_						(   self      :     Union[str, Any]		):
												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  UpperCamelCase_						(   self      :     Optional[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  UpperCamelCase_						(   self      :     Tuple		):
												_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		)
