





"""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			):
       """simple docstring"""




       __magic_name__	:Optional[int]						    =   MODEL_FOR_CAUSAL_LM_MAPPING
       __magic_name__	:Optional[Any]						    =   TF_MODEL_FOR_CAUSAL_LM_MAPPING






       @require_torch
       def 	snake_case		(       self ):



         '''simple docstring'''

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

         lowerCAmelCase__     :Optional[int]											=				text_generator(['This is a test', 'This is a second test'] )
         self.assertEqual(
             __UpperCAmelCase       ,					[
                 [
                     {
                         '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@@'
                         )
                     }
                 ],
             ]       ,					)

         lowerCAmelCase__     :Optional[int]											=				text_generator('This is a test'       ,					do_sample=__UpperCAmelCase       ,					num_return_sequences=2       ,					return_tensors=__UpperCAmelCase )
         self.assertEqual(
             __UpperCAmelCase       ,					[
                 {'generated_token_ids': ANY(__UpperCAmelCase )},
                 {'generated_token_ids': ANY(__UpperCAmelCase )},
             ]       ,					)
         lowerCAmelCase__     :Optional[int]											=				text_generator.model.config.eos_token_id
         lowerCAmelCase__     :int											=				'<pad>'
         lowerCAmelCase__     :Union[str, Any]											=				text_generator(
             ['This is a test', 'This is a second test']       ,					do_sample=__UpperCAmelCase       ,					num_return_sequences=2       ,					batch_size=2       ,					return_tensors=__UpperCAmelCase       ,					)
         self.assertEqual(
             __UpperCAmelCase       ,					[
                 [
                     {'generated_token_ids': ANY(__UpperCAmelCase )},
                     {'generated_token_ids': ANY(__UpperCAmelCase )},
                 ],
                 [
                     {'generated_token_ids': ANY(__UpperCAmelCase )},
                     {'generated_token_ids': ANY(__UpperCAmelCase )},
                 ],
             ]       ,					)






       @require_tf
       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :List[Any]											=				pipeline(task='text-generation'       ,					model='sshleifer/tiny-ctrl'       ,					framework='tf' )

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

         lowerCAmelCase__     :Union[str, Any]											=				text_generator(['This is a test', 'This is a second test']       ,					do_sample=__UpperCAmelCase )
         self.assertEqual(
             __UpperCAmelCase       ,					[
                 [
                     {
                         '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       ,					__UpperCAmelCase       ,					__UpperCAmelCase       ,					__UpperCAmelCase ):



         '''simple docstring'''

         lowerCAmelCase__     :Union[str, Any]											=				TextGenerationPipeline(model=__UpperCAmelCase       ,					tokenizer=__UpperCAmelCase )
         return text_generator, ["This is a test", "Another test"]






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :Union[str, Any]											=				'Hello I believe in'
         lowerCAmelCase__     :Any											=				pipeline('text-generation'       ,					model='hf-internal-testing/tiny-random-gpt2' )
         lowerCAmelCase__     :Union[str, Any]											=				text_generator(__UpperCAmelCase )
         self.assertEqual(
             __UpperCAmelCase       ,					[{'generated_text': 'Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'}]       ,					)

         lowerCAmelCase__     :Optional[int]											=				text_generator(__UpperCAmelCase       ,					stop_sequence=' fe' )
         self.assertEqual(__UpperCAmelCase       ,					[{'generated_text': 'Hello I believe in fe'}] )






       def 	snake_case		(       self       ,					__UpperCAmelCase       ,					__UpperCAmelCase ):



         '''simple docstring'''

         lowerCAmelCase__     :Any											=				text_generator.model
         lowerCAmelCase__     :Dict											=				text_generator.tokenizer

         lowerCAmelCase__     :Any											=				text_generator('This is a test' )
         self.assertEqual(__UpperCAmelCase       ,					[{'generated_text': ANY(__UpperCAmelCase )}] )
         self.assertTrue(outputs[0]['generated_text'].startswith('This is a test' ) )

         lowerCAmelCase__     :Dict											=				text_generator('This is a test'       ,					return_full_text=__UpperCAmelCase )
         self.assertEqual(__UpperCAmelCase       ,					[{'generated_text': ANY(__UpperCAmelCase )}] )
         self.assertNotIn('This is a test'       ,					outputs[0]['generated_text'] )

         lowerCAmelCase__     :str											=				pipeline(task='text-generation'       ,					model=__UpperCAmelCase       ,					tokenizer=__UpperCAmelCase       ,					return_full_text=__UpperCAmelCase )
         lowerCAmelCase__     :Optional[int]											=				text_generator('This is a test' )
         self.assertEqual(__UpperCAmelCase       ,					[{'generated_text': ANY(__UpperCAmelCase )}] )
         self.assertNotIn('This is a test'       ,					outputs[0]['generated_text'] )

         lowerCAmelCase__     :Optional[Any]											=				text_generator('This is a test'       ,					return_full_text=__UpperCAmelCase )
         self.assertEqual(__UpperCAmelCase       ,					[{'generated_text': ANY(__UpperCAmelCase )}] )
         self.assertTrue(outputs[0]['generated_text'].startswith('This is a test' ) )

         lowerCAmelCase__     :int											=				text_generator(['This is great !', 'Something else']       ,					num_return_sequences=2       ,					do_sample=__UpperCAmelCase )
         self.assertEqual(
             __UpperCAmelCase       ,					[
                 [{'generated_text': ANY(__UpperCAmelCase )}, {'generated_text': ANY(__UpperCAmelCase )}],
                 [{'generated_text': ANY(__UpperCAmelCase )}, {'generated_text': ANY(__UpperCAmelCase )}],
             ]       ,					)

         if text_generator.tokenizer.pad_token is not None:
           lowerCAmelCase__     :Optional[Any]											=				text_generator(
               ['This is great !', 'Something else']       ,					num_return_sequences=2       ,					batch_size=2       ,					do_sample=__UpperCAmelCase )
           self.assertEqual(
               __UpperCAmelCase       ,					[
                   [{'generated_text': ANY(__UpperCAmelCase )}, {'generated_text': ANY(__UpperCAmelCase )}],
                   [{'generated_text': ANY(__UpperCAmelCase )}, {'generated_text': ANY(__UpperCAmelCase )}],
               ]       ,					)

         with self.assertRaises(__UpperCAmelCase ):
           lowerCAmelCase__     :List[Any]											=				text_generator('test'       ,					return_full_text=__UpperCAmelCase       ,					return_text=__UpperCAmelCase )
         with self.assertRaises(__UpperCAmelCase ):
           lowerCAmelCase__     :Union[str, Any]											=				text_generator('test'       ,					return_full_text=__UpperCAmelCase       ,					return_tensors=__UpperCAmelCase )
         with self.assertRaises(__UpperCAmelCase ):
           lowerCAmelCase__     :str											=				text_generator('test'       ,					return_text=__UpperCAmelCase       ,					return_tensors=__UpperCAmelCase )

         # 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__
         ):
           lowerCAmelCase__     :Dict											=				text_generator('' )
           self.assertEqual(__UpperCAmelCase       ,					[{'generated_text': ANY(__UpperCAmelCase )}] )
         else:
           with self.assertRaises((ValueError, AssertionError) ):
             lowerCAmelCase__     :str											=				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.
         lowerCAmelCase__     :int											=				['RwkvForCausalLM', 'XGLMForCausalLM', 'GPTNeoXForCausalLM']
         if (
             tokenizer.model_max_length < 1_0_0_0_0
             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_0_0       ,					max_new_tokens=2_0 )

           lowerCAmelCase__     :int											=				text_generator('This is a test' * 5_0_0       ,					handle_long_generation='hole'       ,					max_new_tokens=2_0 )
           # Hole strategy cannot work
           with self.assertRaises(__UpperCAmelCase ):
             text_generator(
                 'This is a test' * 5_0_0       ,					handle_long_generation='hole'       ,					max_new_tokens=tokenizer.model_max_length + 1_0       ,					)






       @require_torch
       @require_accelerate
       @require_torch_gpu
       def 	snake_case		(       self ):



         '''simple docstring'''

         import torch

         # Classic `model_kwargs`
         lowerCAmelCase__     :Optional[int]											=				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 )
         lowerCAmelCase__     :Dict											=				pipe('This is a test' )
         self.assertEqual(
             __UpperCAmelCase       ,					[
                 {
                     '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.)
         lowerCAmelCase__     :Union[str, Any]											=				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 )
         lowerCAmelCase__     :Union[str, Any]											=				pipe('This is a test' )
         self.assertEqual(
             __UpperCAmelCase       ,					[
                 {
                     '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
         lowerCAmelCase__     :List[str]											=				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 )
         lowerCAmelCase__     :Any											=				pipe('This is a test' )
         self.assertEqual(
             __UpperCAmelCase       ,					[
                 {
                     '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 ):



         '''simple docstring'''

         import torch

         lowerCAmelCase__     :List[str]											=				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 ):



         '''simple docstring'''

         import torch

         lowerCAmelCase__     :Union[str, Any]											=				pipeline(model='hf-internal-testing/tiny-random-bloom'       ,					device_map='auto'       ,					torch_dtype=torch.floataa )
         pipe('This is a test'       ,					do_sample=__UpperCAmelCase       ,					top_p=0.5 )






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :str											=				'Hello world'
         lowerCAmelCase__     :Optional[Any]											=				pipeline('text-generation'       ,					model='hf-internal-testing/tiny-random-gpt2' )
         if text_generator.model.framework == "tf":
           lowerCAmelCase__     :Any											=				logging.get_logger('transformers.generation.tf_utils' )
         else:
           lowerCAmelCase__     :List[str]											=				logging.get_logger('transformers.generation.utils' )
         lowerCAmelCase__     :Union[str, Any]											=				'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(__UpperCAmelCase ) as cl:
           lowerCAmelCase__     :Optional[Any]											=				text_generator(__UpperCAmelCase       ,					max_length=1_0       ,					max_new_tokens=1 )
         self.assertIn(__UpperCAmelCase       ,					cl.out )

         # The user only sets one -> no warning
         with CaptureLogger(__UpperCAmelCase ) as cl:
           lowerCAmelCase__     :List[str]											=				text_generator(__UpperCAmelCase       ,					max_new_tokens=1 )
         self.assertNotIn(__UpperCAmelCase       ,					cl.out )

         with CaptureLogger(__UpperCAmelCase ) as cl:
           lowerCAmelCase__     :Dict											=				text_generator(__UpperCAmelCase       ,					max_length=1_0 )
         self.assertNotIn(__UpperCAmelCase       ,					cl.out )




from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


A			:						Any        =  logging.get_logger(__name__)

A			:						Tuple        =  {
    'sail/poolformer_s12': 'https://huggingface.co/sail/poolformer_s12/resolve/main/config.json',
    # See all PoolFormer models at https://huggingface.co/models?filter=poolformer
}



class 				A       (			UpperCAmelCase__				):
					'''simple docstring'''






					A__     =					'''poolformer'''

					def __init__(self       :		Dict ,   _UpperCAmelCase       :		Union[str, Any]=3 ,   _UpperCAmelCase       :		str=16 ,   _UpperCAmelCase       :		Any=16 ,   _UpperCAmelCase       :		Union[str, Any]=3 ,   _UpperCAmelCase       :		Union[str, Any]=4.0 ,   _UpperCAmelCase       :		str=[2, 2, 6, 2] ,   _UpperCAmelCase       :		int=[64, 128, 320, 512] ,   _UpperCAmelCase       :		Union[str, Any]=[7, 3, 3, 3] ,   _UpperCAmelCase       :		List[Any]=[4, 2, 2, 2] ,   _UpperCAmelCase       :		Union[str, Any]=[2, 1, 1, 1] ,   _UpperCAmelCase       :		Optional[Any]=4 ,   _UpperCAmelCase       :		Dict=0.0 ,   _UpperCAmelCase       :		Union[str, Any]="gelu" ,   _UpperCAmelCase       :		Optional[Any]=True ,   _UpperCAmelCase       :		Tuple=1E-5 ,   _UpperCAmelCase       :		Tuple=0.02 ,   **_UpperCAmelCase       :		Union[str, Any] ,   )		->  Optional[int]:




							"""simple docstring"""


							lowercase__	     =						num_channels
							lowercase__	     =						patch_size
							lowercase__	     =						stride
							lowercase__	     =						padding
							lowercase__	     =						pool_size
							lowercase__	     =						hidden_sizes
							lowercase__	     =						mlp_ratio
							lowercase__	     =						depths
							lowercase__	     =						patch_sizes
							lowercase__	     =						strides
							lowercase__	     =						num_encoder_blocks
							lowercase__	     =						drop_path_rate
							lowercase__	     =						hidden_act
							lowercase__	     =						use_layer_scale
							lowercase__	     =						layer_scale_init_value
							lowercase__	     =						initializer_range
							super().__init__(**_UpperCAmelCase						)






class 				A       (			UpperCAmelCase__				):
					'''simple docstring'''






					A__     =					version.parse('''1.11'''				)

					@property
					def     lowerCamelCase__	(self       :		List[str]						)		->  Mapping[str, Mapping[int, str]]:




							"""simple docstring"""


							return OrderedDict(
							    [
							        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
							    ]						)


					@property
					def     lowerCamelCase__	(self       :		Dict						)		->  float:




							"""simple docstring"""


							return 2E-3

