




'''simple docstring'''


import argparse
import logging

import numpy as np
import torch

from transformers import AutoModelForCausalLM, AutoTokenizer


logging.basicConfig(
    format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s''',
    datefmt='''%m/%d/%Y %H:%M:%S''',
    level=logging.INFO,
)
UpperCamelCase     =				logging.getLogger(__name__)
def 				SCREAMING_SNAKE_CASE(      __lowercase  ) ->   List[str]:
     np.random.seed(args.seed  )
     torch.manual_seed(args.seed  )
     if args.n_gpu > 0:
          torch.cuda.manual_seed_all(args.seed  )
def 				SCREAMING_SNAKE_CASE(      ) ->   List[str]:
     A:		List[str]        =		argparse.ArgumentParser()
     parser.add_argument(
         '''--model_name_or_path'''		,							default=__lowercase		,							type=__lowercase		,							required=__lowercase		,							)
     parser.add_argument('''--prompt'''		,							type=__lowercase		,							default=''''''  )
     parser.add_argument('''--length'''		,							type=__lowercase		,							default=2_0  )
     parser.add_argument('''--stop_token'''		,							type=__lowercase		,							default=__lowercase		,							help='''Token at which text generation is stopped'''  )
     parser.add_argument(
         '''--temperature'''		,							type=__lowercase		,							default=1.0		,							help='''temperature of 1.0 has no effect, lower tend toward greedy sampling'''		,							)
     parser.add_argument(
         '''--repetition_penalty'''		,							type=__lowercase		,							default=1.0		,							help='''primarily useful for CTRL model; in that case, use 1.2'''  )
     parser.add_argument('''--k'''		,							type=__lowercase		,							default=0  )
     parser.add_argument('''--penalty_alpha'''		,							type=__lowercase		,							default=0.0  )
     parser.add_argument('''--p'''		,							type=__lowercase		,							default=0.9  )

     parser.add_argument('''--prefix'''		,							type=__lowercase		,							default=''''''		,							help='''Text added prior to input.'''  )
     parser.add_argument('''--padding_text'''		,							type=__lowercase		,							default=''''''		,							help='''Deprecated, the use of `--prefix` is preferred.'''  )
     parser.add_argument('''--xlm_language'''		,							type=__lowercase		,							default=''''''		,							help='''Optional language when used with the XLM model.'''  )

     parser.add_argument('''--seed'''		,							type=__lowercase		,							default=4_2		,							help='''random seed for initialization'''  )
     parser.add_argument('''--no_cuda'''		,							action='''store_true'''		,							help='''Avoid using CUDA when available'''  )
     parser.add_argument(
         '''--fp16'''		,							action='''store_true'''		,							help='''Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit'''		,							)
     A:		str        =		parser.parse_args()

     A:		Tuple        =		torch.device('''cuda''' if torch.cuda.is_available() and not args.no_cuda else '''cpu'''  )
     A:		Union[str, Any]        =		0 if args.no_cuda else torch.cuda.device_count()

     logger.warning(F"""device: {args.device}, n_gpu: {args.n_gpu}, 16-bits training: {args.fpaa}"""  )

     set_seed(__lowercase  )

     # Initialize the model and tokenizer
     A:		Dict        =		AutoTokenizer.from_pretrained(args.model_name_or_path  )
     A:		List[Any]        =		AutoModelForCausalLM.from_pretrained(args.model_name_or_path  )

     # tokenizer = GPT2Tokenizer.from_pretrained(args.model_name_or_path)
     # model = OPTForCausalLM.from_pretrained(args.model_name_or_path)
     model.to(args.device  )

     if args.fpaa:
          model.half()

     logger.info(__lowercase  )
     A:		Tuple        =		args.prompt if args.prompt else input('''Model prompt >>> '''  )

     A:		Tuple        =		tokenizer(__lowercase		,							return_tensors='''pt'''		,							add_special_tokens=__lowercase  )
     A:		int        =		{key: value.to(args.device  ) for key, value in inputs.items()}

     A:		Any        =		model.generate(
         **__lowercase		,							max_length=args.length + len(inputs['''input_ids'''][0]  )		,							penalty_alpha=args.penalty_alpha		,							top_k=args.k		,							)

     A:		List[Any]        =		[]
     for generated_sequence_idx, generated_sequence in enumerate(__lowercase  ):
          print(F"""=== GENERATED SEQUENCE {generated_sequence_idx + 1} ==="""  )
          A:		Tuple        =		generated_sequence.tolist()

          # Decode text
          A:		Optional[Any]        =		tokenizer.decode(__lowercase		,							clean_up_tokenization_spaces=__lowercase		,							add_special_tokens=__lowercase  )

          # Remove all text after the stop token
          A:		List[Any]        =		text[: text.find(args.stop_token  ) if args.stop_token else None]

          # Add the prompt at the beginning of the sequence. Remove the excess text that was used for pre-processing
          A:		int        =		(
              prompt_text + text[len(tokenizer.decode(inputs['''input_ids'''][0]		,							clean_up_tokenization_spaces=__lowercase  )  ) :]
          )

          generated_sequences.append(__lowercase  )
          print(__lowercase  )

     return generated_sequences


if __name__ == "__main__":
     main()












'''simple docstring'''


import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
     import torch

if is_vision_available():
     from PIL import Image

     from transformers import SegformerImageProcessor






class 	lowerCAmelCase_  (					unittest.TestCase       ):







  '''simple docstring'''

  def __init__(   self							:       Dict				,     SCREAMING_SNAKE_CASE_							:       Dict				,     SCREAMING_SNAKE_CASE_							:       Any=7				,     SCREAMING_SNAKE_CASE_							:       Dict=3				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]=30				,     SCREAMING_SNAKE_CASE_							:       List[Any]=4_00				,     SCREAMING_SNAKE_CASE_							:       str=True				,     SCREAMING_SNAKE_CASE_							:       List[Any]=None				,     SCREAMING_SNAKE_CASE_							:       Optional[int]=True				,     SCREAMING_SNAKE_CASE_							:       List[str]=[0.5, 0.5, 0.5]				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]=[0.5, 0.5, 0.5]				,     SCREAMING_SNAKE_CASE_							:       Tuple=False				,     ) ->		str:







       '''simple docstring'''



       A:		Dict        =		size if size is not None else {'''height''': 30, '''width''': 30}
       A:		List[Any]        =		parent
       A:		Tuple        =		batch_size
       A:		List[str]        =		num_channels
       A:		Dict        =		min_resolution
       A:		str        =		max_resolution
       A:		int        =		do_resize
       A:		List[str]        =		size
       A:		int        =		do_normalize
       A:		Optional[int]        =		image_mean
       A:		Optional[int]        =		image_std
       A:		Any        =		do_reduce_labels




  def 				_snake_case    (   self							:       Any  ) ->		List[str]:







       '''simple docstring'''



       return {
           "do_resize": self.do_resize,
           "size": self.size,
           "do_normalize": self.do_normalize,
           "image_mean": self.image_mean,
           "image_std": self.image_std,
           "do_reduce_labels": self.do_reduce_labels,
       }






def 				SCREAMING_SNAKE_CASE(      ) ->   List[Any]:
     A:		Dict        =		load_dataset('''hf-internal-testing/fixtures_ade20k'''		,							split='''test'''  )

     A:		Any        =		Image.open(dataset[0]['''file''']  )
     A:		Dict        =		Image.open(dataset[1]['''file''']  )

     return image, map
def 				SCREAMING_SNAKE_CASE(      ) ->   List[Any]:
     A:		Optional[Any]        =		load_dataset('''hf-internal-testing/fixtures_ade20k'''		,							split='''test'''  )

     A:		Union[str, Any]        =		Image.open(dataset[0]['''file''']  )
     A:		str        =		Image.open(dataset[1]['''file''']  )
     A:		str        =		Image.open(dataset[2]['''file''']  )
     A:		Any        =		Image.open(dataset[3]['''file''']  )

     return [imagea, imagea], [mapa, mapa]






@require_torch
@require_vision
class 	lowerCAmelCase_  (					UpperCAmelCase_					,				unittest.TestCase       ):







  '''simple docstring'''

  UpperCamelCase_ :			int        =							SegformerImageProcessor if is_vision_available() else None



  def 				_snake_case    (   self							:       List[str]  ) ->		str:







       '''simple docstring'''



       A:		Dict        =		SegformerImageProcessingTester(self  )



  @property
  def 				_snake_case    (   self							:       Tuple  ) ->		List[str]:







       '''simple docstring'''



       return self.image_processor_tester.prepare_image_processor_dict()



  def 				_snake_case    (   self							:       Optional[int]  ) ->		Optional[Any]:







       '''simple docstring'''



       A:		Optional[int]        =		self.image_processing_class(**self.image_processor_dict  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''do_resize'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''size'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''do_normalize'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''image_mean'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''image_std'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''do_reduce_labels'''  )  )



  def 				_snake_case    (   self							:       List[str]  ) ->		Union[str, Any]:







       '''simple docstring'''



       A:		Tuple        =		self.image_processing_class.from_dict(self.image_processor_dict  )
       self.assertEqual(image_processor.size				,     {'''height''': 30, '''width''': 30}  )
       self.assertEqual(image_processor.do_reduce_labels				,     SCREAMING_SNAKE_CASE_  )

       A:		str        =		self.image_processing_class.from_dict(self.image_processor_dict				,     size=42				,     reduce_labels=SCREAMING_SNAKE_CASE_  )
       self.assertEqual(image_processor.size				,     {'''height''': 42, '''width''': 42}  )
       self.assertEqual(image_processor.do_reduce_labels				,     SCREAMING_SNAKE_CASE_  )



  def 				_snake_case    (   self							:       Union[str, Any]  ) ->		Any:







       '''simple docstring'''



       pass



  def 				_snake_case    (   self							:       Any  ) ->		Dict:







       '''simple docstring'''



       A:		Dict        =		self.image_processing_class(**self.image_processor_dict  )
       # create random PIL images
       A:		Optional[Any]        =		prepare_image_inputs(self.image_processor_tester				,     equal_resolution=SCREAMING_SNAKE_CASE_  )
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_				,     Image.Image  )

       # Test not batched input
       A:		List[str]        =		image_processing(image_inputs[0]				,     return_tensors='''pt'''  ).pixel_values
       self.assertEqual(
           encoded_images.shape				,     (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )

       # Test batched
       A:		int        =		image_processing(SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  ).pixel_values
       self.assertEqual(
           encoded_images.shape				,     (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )



  def 				_snake_case    (   self							:       str  ) ->		Tuple:







       '''simple docstring'''



       A:		int        =		self.image_processing_class(**self.image_processor_dict  )
       # create random numpy tensors
       A:		Optional[Any]        =		prepare_image_inputs(self.image_processor_tester				,     equal_resolution=SCREAMING_SNAKE_CASE_				,     numpify=SCREAMING_SNAKE_CASE_  )
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_				,     np.ndarray  )

       # Test not batched input
       A:		Dict        =		image_processing(image_inputs[0]				,     return_tensors='''pt'''  ).pixel_values
       self.assertEqual(
           encoded_images.shape				,     (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )

       # Test batched
       A:		Any        =		image_processing(SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  ).pixel_values
       self.assertEqual(
           encoded_images.shape				,     (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )



  def 				_snake_case    (   self							:       str  ) ->		str:







       '''simple docstring'''



       A:		List[Any]        =		self.image_processing_class(**self.image_processor_dict  )
       # create random PyTorch tensors
       A:		str        =		prepare_image_inputs(self.image_processor_tester				,     equal_resolution=SCREAMING_SNAKE_CASE_				,     torchify=SCREAMING_SNAKE_CASE_  )
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_				,     torch.Tensor  )

       # Test not batched input
       A:		Any        =		image_processing(image_inputs[0]				,     return_tensors='''pt'''  ).pixel_values
       self.assertEqual(
           encoded_images.shape				,     (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )

       # Test batched
       A:		List[Any]        =		image_processing(SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  ).pixel_values
       self.assertEqual(
           encoded_images.shape				,     (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )



  def 				_snake_case    (   self							:       Dict  ) ->		Optional[Any]:







       '''simple docstring'''



       A:		Optional[int]        =		self.image_processing_class(**self.image_processor_dict  )
       # create random PyTorch tensors
       A:		Optional[int]        =		prepare_image_inputs(self.image_processor_tester				,     equal_resolution=SCREAMING_SNAKE_CASE_				,     torchify=SCREAMING_SNAKE_CASE_  )
       A:		Optional[Any]        =		[]
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_				,     torch.Tensor  )
            maps.append(torch.zeros(image.shape[-2:]  ).long()  )

       # Test not batched input
       A:		Tuple        =		image_processing(image_inputs[0]				,     maps[0]				,     return_tensors='''pt'''  )
       self.assertEqual(
           encoding['''pixel_values'''].shape				,     (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )
       self.assertEqual(
           encoding['''labels'''].shape				,     (
               1,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )
       self.assertEqual(encoding['''labels'''].dtype				,     torch.long  )
       self.assertTrue(encoding['''labels'''].min().item() >= 0  )
       self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )

       # Test batched
       A:		Union[str, Any]        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  )
       self.assertEqual(
           encoding['''pixel_values'''].shape				,     (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )
       self.assertEqual(
           encoding['''labels'''].shape				,     (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )
       self.assertEqual(encoding['''labels'''].dtype				,     torch.long  )
       self.assertTrue(encoding['''labels'''].min().item() >= 0  )
       self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )

       # Test not batched input (PIL images)
       A    ,						A:		int        =		prepare_semantic_single_inputs()

       A:		Dict        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  )
       self.assertEqual(
           encoding['''pixel_values'''].shape				,     (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )
       self.assertEqual(
           encoding['''labels'''].shape				,     (
               1,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )
       self.assertEqual(encoding['''labels'''].dtype				,     torch.long  )
       self.assertTrue(encoding['''labels'''].min().item() >= 0  )
       self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )

       # Test batched input (PIL images)
       A    ,						A:		int        =		prepare_semantic_batch_inputs()

       A:		int        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  )
       self.assertEqual(
           encoding['''pixel_values'''].shape				,     (
               2,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )
       self.assertEqual(
           encoding['''labels'''].shape				,     (
               2,
               self.image_processor_tester.size['''height'''],
               self.image_processor_tester.size['''width'''],
           )				,     )
       self.assertEqual(encoding['''labels'''].dtype				,     torch.long  )
       self.assertTrue(encoding['''labels'''].min().item() >= 0  )
       self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )




  def 				_snake_case    (   self							:       Tuple  ) ->		Union[str, Any]:







       '''simple docstring'''



       A:		Any        =		self.image_processing_class(**self.image_processor_dict  )

       # ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
       A    ,						A:		Union[str, Any]        =		prepare_semantic_single_inputs()
       A:		Optional[int]        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  )
       self.assertTrue(encoding['''labels'''].min().item() >= 0  )
       self.assertTrue(encoding['''labels'''].max().item() <= 1_50  )

       A:		Optional[int]        =		True
       A:		str        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  )
       self.assertTrue(encoding['''labels'''].min().item() >= 0  )
       self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )






