code: 
  
  
  
  
  
  import unittest
  
  import numpy as np
  
  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 EfficientNetImageProcessor
  
  
  
  
  
  
  class 	UpperCamelCase_     (     unittest.TestCase       ):
  
  
  
  					def __init__(		self    :    Tuple					,			lowerCamelCase    :    Dict					,			lowerCamelCase    :    Optional[int]=13					,			lowerCamelCase    :    int=3					,			lowerCamelCase    :    str=18					,			lowerCamelCase    :    Optional[int]=30					,			lowerCamelCase    :    Optional[int]=4_00					,			lowerCamelCase    :    Optional[Any]=True					,			lowerCamelCase    :    Tuple=None					,			lowerCamelCase    :    Dict=True					,			lowerCamelCase    :    List[Any]=[0.5, 0.5, 0.5]					,			lowerCamelCase    :    Tuple=[0.5, 0.5, 0.5]					,			):
  							lowerCamelCase_  :    Dict   	=			size if size is not None else {'height': 18, 'width': 18}
  							lowerCamelCase_  :    Any   	=			parent
  							lowerCamelCase_  :    int   	=			batch_size
  							lowerCamelCase_  :    List[str]   	=			num_channels
  							lowerCamelCase_  :    Dict   	=			image_size
  							lowerCamelCase_  :    Dict   	=			min_resolution
  							lowerCamelCase_  :    List[Any]   	=			max_resolution
  							lowerCamelCase_  :    str   	=			do_resize
  							lowerCamelCase_  :    int   	=			size
  							lowerCamelCase_  :    Optional[Any]   	=			do_normalize
  							lowerCamelCase_  :    Tuple   	=			image_mean
  							lowerCamelCase_  :    Optional[int]   	=			image_std
  
  
  
  
  
  					def      __a    (		self    :    str	):
  							return {
  							    "image_mean": self.image_mean,
  							    "image_std": self.image_std,
  							    "do_normalize": self.do_normalize,
  							    "do_resize": self.do_resize,
  							    "size": self.size,
  							}
  
  
  
  
  
  
  @require_torch
  @require_vision
  class 	UpperCamelCase_     (     snake_case__     ,    unittest.TestCase       ):
  					_a			:	List[str]							=				EfficientNetImageProcessor if is_vision_available() else None
  
  
  
  					def      __a    (		self    :    Optional[int]	):
  							lowerCamelCase_  :    Dict   	=			EfficientNetImageProcessorTester(self	)
  
  
  
  					@property
  					def      __a    (		self    :    Tuple	):
  							return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  					def      __a    (		self    :    str	):
  							lowerCamelCase_  :    List[Any]   	=			self.image_processing_class(**self.image_processor_dict	)
  							self.assertTrue(hasattr(lowerCamelCase					,			'image_mean'	)	)
  							self.assertTrue(hasattr(lowerCamelCase					,			'image_std'	)	)
  							self.assertTrue(hasattr(lowerCamelCase					,			'do_normalize'	)	)
  							self.assertTrue(hasattr(lowerCamelCase					,			'do_resize'	)	)
  							self.assertTrue(hasattr(lowerCamelCase					,			'size'	)	)
  
  
  
  					def      __a    (		self    :    Union[str, Any]	):
  							lowerCamelCase_  :    Optional[int]   	=			self.image_processing_class.from_dict(self.image_processor_dict	)
  							self.assertEqual(image_processor.size					,			{'height': 18, 'width': 18}	)
  
  							lowerCamelCase_  :    Dict   	=			self.image_processing_class.from_dict(self.image_processor_dict					,			size=42	)
  							self.assertEqual(image_processor.size					,			{'height': 42, 'width': 42}	)
  
  
  
  					def      __a    (		self    :    List[Any]	):
  							# Initialize image_processing
  							lowerCamelCase_  :    Union[str, Any]   	=			self.image_processing_class(**self.image_processor_dict	)
  							# create random PIL images
  							lowerCamelCase_  :    List[Any]   	=			prepare_image_inputs(self.image_processor_tester					,			equal_resolution=lowerCamelCase	)
  							for image in image_inputs:
  									self.assertIsInstance(lowerCamelCase					,			Image.Image	)
  
  							# Test not batched input
  							lowerCamelCase_  :    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
  							lowerCamelCase_  :    List[str]   	=			image_processing(lowerCamelCase					,			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      __a    (		self    :    List[str]	):
  							# Initialize image_processing
  							lowerCamelCase_  :    Any   	=			self.image_processing_class(**self.image_processor_dict	)
  							# create random numpy tensors
  							lowerCamelCase_  :    int   	=			prepare_image_inputs(self.image_processor_tester					,			equal_resolution=lowerCamelCase					,			numpify=lowerCamelCase	)
  							for image in image_inputs:
  									self.assertIsInstance(lowerCamelCase					,			np.ndarray	)
  
  							# Test not batched input
  							lowerCamelCase_  :    Optional[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
  							lowerCamelCase_  :    Optional[int]   	=			image_processing(lowerCamelCase					,			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      __a    (		self    :    List[Any]	):
  							# Initialize image_processing
  							lowerCamelCase_  :    Union[str, Any]   	=			self.image_processing_class(**self.image_processor_dict	)
  							# create random PyTorch tensors
  							lowerCamelCase_  :    Union[str, Any]   	=			prepare_image_inputs(self.image_processor_tester					,			equal_resolution=lowerCamelCase					,			torchify=lowerCamelCase	)
  							for image in image_inputs:
  									self.assertIsInstance(lowerCamelCase					,			torch.Tensor	)
  
  							# Test not batched input
  							lowerCamelCase_  :    Union[str, 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
  							lowerCamelCase_  :    Union[str, Any]   	=			image_processing(lowerCamelCase					,			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'],
  							    )					,			)
  
style_context: 
  
  
  
  
  
  import unittest
  
  import requests
  
  from transformers import MODEL_FOR_VISION_2_SEQ_MAPPING, TF_MODEL_FOR_VISION_2_SEQ_MAPPING, is_vision_available
  from transformers.pipelines import pipeline
  from transformers.testing_utils import (
      is_pipeline_test,
      is_torch_available,
      require_tf,
      require_torch,
      require_vision,
      slow,
  )
  
  from .test_pipelines_common import ANY
  
  
  if is_torch_available():
  		from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
  else:
  		_lowercase		:     Dict 					=False
  
  
  if is_vision_available():
  		from PIL import Image
  else:
  
  
  
  
  
  
  		class 	UpperCamelCase_     :
  
  
  
  							@staticmethod
  							def      __a    (		*lowerCamelCase    :    Any					,			**lowerCamelCase    :    List[Any]	):
  									pass
  
  
  
  
  
  
  @is_pipeline_test
  @require_vision
  class 	UpperCamelCase_     (     unittest.TestCase       ):
  					_a			:	int							=				MODEL_FOR_VISION_2_SEQ_MAPPING
  					_a			:	int							=				TF_MODEL_FOR_VISION_2_SEQ_MAPPING
  
  
  
  					def      __a    (		self    :    int					,			lowerCamelCase    :    Union[str, Any]					,			lowerCamelCase    :    Optional[int]					,			lowerCamelCase    :    Union[str, Any]	):
  							lowerCamelCase_  :    List[str]   	=			pipeline('image-to-text'					,			model=lowerCamelCase					,			tokenizer=lowerCamelCase					,			image_processor=lowerCamelCase	)
  							lowerCamelCase_  :    str   	=			[
  							    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	),
  							    './tests/fixtures/tests_samples/COCO/000000039769.png',
  							]
  							return pipe, examples
  
  
  
  					def      __a    (		self    :    List[Any]					,			lowerCamelCase    :    Any					,			lowerCamelCase    :    List[str]	):
  							lowerCamelCase_  :    str   	=			pipe(lowerCamelCase	)
  							self.assertEqual(
  							    lowerCamelCase					,			[
  							        [{'generated_text': ANY(lowerCamelCase	)}],
  							        [{'generated_text': ANY(lowerCamelCase	)}],
  							    ]					,			)
  
  
  
  					@require_tf
  					def      __a    (		self    :    Union[str, Any]	):
  							lowerCamelCase_  :    Tuple   	=			pipeline('image-to-text'					,			model='hf-internal-testing/tiny-random-vit-gpt2'					,			framework='tf'	)
  							lowerCamelCase_  :    Optional[int]   	=			'./tests/fixtures/tests_samples/COCO/000000039769.png'
  
  							lowerCamelCase_  :    Optional[int]   	=			pipe(lowerCamelCase	)
  							self.assertEqual(
  							    lowerCamelCase					,			[
  							        {
  							            'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
  							        },
  							    ]					,			)
  
  							lowerCamelCase_  :    List[Any]   	=			pipe([image, image]	)
  							self.assertEqual(
  							    lowerCamelCase					,			[
  							        [
  							            {
  							                'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
  							            }
  							        ],
  							        [
  							            {
  							                'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
  							            }
  							        ],
  							    ]					,			)
  
  							lowerCamelCase_  :    str   	=			pipe(lowerCamelCase					,			max_new_tokens=1	)
  							self.assertEqual(
  							    lowerCamelCase					,			[{'generated_text': 'growth'}]					,			)
  
  
  
  					@require_torch
  					def      __a    (		self    :    Tuple	):
  							lowerCamelCase_  :    Union[str, Any]   	=			pipeline('image-to-text'					,			model='hf-internal-testing/tiny-random-vit-gpt2'	)
  							lowerCamelCase_  :    Any   	=			'./tests/fixtures/tests_samples/COCO/000000039769.png'
  
  							lowerCamelCase_  :    int   	=			pipe(lowerCamelCase	)
  							self.assertEqual(
  							    lowerCamelCase					,			[
  							        {
  							            'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
  							        },
  							    ]					,			)
  
  							lowerCamelCase_  :    Tuple   	=			pipe([image, image]	)
  							self.assertEqual(
  							    lowerCamelCase					,			[
  							        [
  							            {
  							                'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
  							            }
  							        ],
  							        [
  							            {
  							                'generated_text': 'growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'
  							            }
  							        ],
  							    ]					,			)
  
  
  
  					@require_torch
  					def      __a    (		self    :    Dict	):
  							lowerCamelCase_  :    Any   	=			pipeline('image-to-text'					,			model='hf-internal-testing/tiny-random-BlipForConditionalGeneration'	)
  							lowerCamelCase_  :    List[Any]   	=			'./tests/fixtures/tests_samples/COCO/000000039769.png'
  							lowerCamelCase_  :    List[Any]   	=			'a photo of'
  
  							lowerCamelCase_  :    Dict   	=			pipe(lowerCamelCase					,			prompt=lowerCamelCase	)
  							self.assertTrue(outputs[0]['generated_text'].startswith(lowerCamelCase	)	)
  
  
  
  					@slow
  					@require_torch
  					def      __a    (		self    :    Union[str, Any]	):
  							lowerCamelCase_  :    List[str]   	=			pipeline('image-to-text'					,			model='ydshieh/vit-gpt2-coco-en'	)
  							lowerCamelCase_  :    Any   	=			'./tests/fixtures/tests_samples/COCO/000000039769.png'
  
  							lowerCamelCase_  :    str   	=			pipe(lowerCamelCase	)
  							self.assertEqual(lowerCamelCase					,			[{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}]	)
  
  							lowerCamelCase_  :    Union[str, Any]   	=			pipe([image, image]	)
  							self.assertEqual(
  							    lowerCamelCase					,			[
  							        [{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}],
  							        [{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}],
  							    ]					,			)
  
  
  
  					@slow
  					@require_torch
  					def      __a    (		self    :    List[Any]	):
  							lowerCamelCase_  :    int   	=			pipeline('image-to-text'					,			model='Salesforce/blip-image-captioning-base'	)
  							lowerCamelCase_  :    Tuple   	=			'https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'
  							lowerCamelCase_  :    List[Any]   	=			Image.open(requests.get(lowerCamelCase					,			stream=lowerCamelCase	).raw	)
  
  							lowerCamelCase_  :    Optional[Any]   	=			pipe(lowerCamelCase	)
  							self.assertEqual(lowerCamelCase					,			[{'generated_text': 'a pink pokemon pokemon with a blue shirt and a blue shirt'}]	)
  
  
  
  					@slow
  					@require_torch
  					def      __a    (		self    :    List[str]	):
  							lowerCamelCase_  :    Optional[Any]   	=			pipeline('image-to-text'					,			model='microsoft/git-base-coco'	)
  							lowerCamelCase_  :    str   	=			'https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'
  							lowerCamelCase_  :    Dict   	=			Image.open(requests.get(lowerCamelCase					,			stream=lowerCamelCase	).raw	)
  
  							lowerCamelCase_  :    Optional[int]   	=			pipe(lowerCamelCase	)
  							self.assertEqual(lowerCamelCase					,			[{'generated_text': 'a cartoon of a purple character.'}]	)
  
  
  
  					@slow
  					@require_torch
  					def      __a    (		self    :    List[str]	):
  							lowerCamelCase_  :    List[Any]   	=			pipeline('image-to-text'					,			model='Salesforce/blip-image-captioning-base'	)
  							lowerCamelCase_  :    int   	=			'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
  							lowerCamelCase_  :    List[str]   	=			Image.open(requests.get(lowerCamelCase					,			stream=lowerCamelCase	).raw	)
  
  							lowerCamelCase_  :    int   	=			'a photography of'
  
  							lowerCamelCase_  :    Tuple   	=			pipe(lowerCamelCase					,			prompt=lowerCamelCase	)
  							self.assertEqual(lowerCamelCase					,			[{'generated_text': 'a photography of a volcano'}]	)
  
  							with self.assertRaises(lowerCamelCase	):
  									lowerCamelCase_  :    Union[str, Any]   	=			pipe([image, image]					,			prompt=[prompt, prompt]	)
  
  
  
  					@slow
  					@require_torch
  					def      __a    (		self    :    int	):
  							lowerCamelCase_  :    Optional[int]   	=			pipeline('image-to-text'					,			model='microsoft/git-base-coco'	)
  							lowerCamelCase_  :    int   	=			'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
  							lowerCamelCase_  :    Optional[Any]   	=			Image.open(requests.get(lowerCamelCase					,			stream=lowerCamelCase	).raw	)
  
  							lowerCamelCase_  :    Optional[int]   	=			'a photo of a'
  
  							lowerCamelCase_  :    Optional[int]   	=			pipe(lowerCamelCase					,			prompt=lowerCamelCase	)
  							self.assertEqual(lowerCamelCase					,			[{'generated_text': 'a photo of a tent with a tent and a tent in the background.'}]	)
  
  							with self.assertRaises(lowerCamelCase	):
  									lowerCamelCase_  :    List[Any]   	=			pipe([image, image]					,			prompt=[prompt, prompt]	)
  
  
  
  					@unittest.skipIf(
  					    not is_torch_greater_or_equal_than_1_11					,			reason='`Pix2StructImageProcessor` requires `torch>=1.11.0`.'	)
  					@slow
  					@require_torch
  					def      __a    (		self    :    Any	):
  							lowerCamelCase_  :    Union[str, Any]   	=			pipeline('image-to-text'					,			model='google/pix2struct-ai2d-base'	)
  							lowerCamelCase_  :    List[str]   	=			'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
  							lowerCamelCase_  :    Tuple   	=			Image.open(requests.get(lowerCamelCase					,			stream=lowerCamelCase	).raw	)
  
  							lowerCamelCase_  :    str   	=			'What does the label 15 represent? (1) lava (2) core (3) tunnel (4) ash cloud'
  
  							lowerCamelCase_  :    Union[str, Any]   	=			pipe(lowerCamelCase					,			prompt=lowerCamelCase	)
  							self.assertEqual(lowerCamelCase					,			[{'generated_text': 'ash cloud'}]	)
  
  							with self.assertRaises(lowerCamelCase	):
  									lowerCamelCase_  :    Optional[Any]   	=			pipe([image, image]					,			prompt=[prompt, prompt]	)
  
  
  
  
  
  					@slow
  					@require_tf
  					def      __a    (		self    :    Dict	):
  							lowerCamelCase_  :    List[str]   	=			pipeline('image-to-text'					,			model='ydshieh/vit-gpt2-coco-en'					,			framework='tf'	)
  							lowerCamelCase_  :    Dict   	=			'./tests/fixtures/tests_samples/COCO/000000039769.png'
  
  							lowerCamelCase_  :    Optional[Any]   	=			pipe(lowerCamelCase	)
  							self.assertEqual(lowerCamelCase					,			[{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}]	)
  
  							lowerCamelCase_  :    List[Any]   	=			pipe([image, image]	)
  							self.assertEqual(
  							    lowerCamelCase					,			[
  							        [{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}],
  							        [{'generated_text': 'a cat laying on a blanket next to a cat laying on a bed '}],
  							    ]					,			)
  