code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  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:
  				_lowerCamelCase				:	Tuple				    =       False
  
  
  if is_vision_available():
  				from PIL import Image
  else:
  
  
  
  				class 							__UpperCAmelCase  :
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  
  
  
  
  						@staticmethod
  						def        A     (*_lowerCAmelCase						:      int      ,      **_lowerCAmelCase						:      List[Any]      ):
  							pass
  
  
  
  @is_pipeline_test
  @require_vision
  class 							__UpperCAmelCase  (       unittest.TestCase						):
  
  
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowerCAmelCase 				=    MODEL_FOR_VISION_2_SEQ_MAPPING
  		__lowerCAmelCase 				=    TF_MODEL_FOR_VISION_2_SEQ_MAPPING
  
  
  
  
  
  
  
  		def        A     (self						:      Any      ,      _lowerCAmelCase						:      Tuple      ,      _lowerCAmelCase						:      Dict      ,      _lowerCAmelCase						:      int      ):
  			A							  =      pipeline("""image-to-text"""      ,      model=_lowerCAmelCase      ,      tokenizer=_lowerCAmelCase      ,      image_processor=_lowerCAmelCase      )
  			A							  =      [
  			    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""      ),
  			    """./tests/fixtures/tests_samples/COCO/000000039769.png""",
  			]
  			return pipe, examples
  
  
  
  
  
  
  
  		def        A     (self						:      Optional[int]      ,      _lowerCAmelCase						:      str      ,      _lowerCAmelCase						:      int      ):
  			A							  =      pipe(_lowerCAmelCase      )
  			self.assertEqual(
  			    _lowerCAmelCase      ,      [
  			        [{"""generated_text""": ANY(_lowerCAmelCase      )}],
  			        [{"""generated_text""": ANY(_lowerCAmelCase      )}],
  			    ]      ,      )
  
  
  
  
  
  
  
  		@require_tf
  		def        A     (self						:      Optional[Any]      ):
  			A							  =      pipeline("""image-to-text"""      ,      model="""hf-internal-testing/tiny-random-vit-gpt2"""      ,      framework="""tf"""      )
  			A							  =      """./tests/fixtures/tests_samples/COCO/000000039769.png"""
  
  			A							  =      pipe(_lowerCAmelCase      )
  			self.assertEqual(
  			    _lowerCAmelCase      ,      [
  			        {
  			            """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
  			        },
  			    ]      ,      )
  
  			A							  =      pipe([image, image]      )
  			self.assertEqual(
  			    _lowerCAmelCase      ,      [
  			        [
  			            {
  			                """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
  			            }
  			        ],
  			        [
  			            {
  			                """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
  			            }
  			        ],
  			    ]      ,      )
  
  			A							  =      pipe(_lowerCAmelCase      ,      max_new_tokens=1      )
  			self.assertEqual(
  			    _lowerCAmelCase      ,      [{"""generated_text""": """growth"""}]      ,      )
  
  
  
  
  
  
  
  		@require_torch
  		def        A     (self						:      Union[str, Any]      ):
  			A							  =      pipeline("""image-to-text"""      ,      model="""hf-internal-testing/tiny-random-vit-gpt2"""      )
  			A							  =      """./tests/fixtures/tests_samples/COCO/000000039769.png"""
  
  			A							  =      pipe(_lowerCAmelCase      )
  			self.assertEqual(
  			    _lowerCAmelCase      ,      [
  			        {
  			            """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
  			        },
  			    ]      ,      )
  
  			A							  =      pipe([image, image]      )
  			self.assertEqual(
  			    _lowerCAmelCase      ,      [
  			        [
  			            {
  			                """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
  			            }
  			        ],
  			        [
  			            {
  			                """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
  			            }
  			        ],
  			    ]      ,      )
  
  
  
  
  
  
  
  		@require_torch
  		def        A     (self						:      int      ):
  			A							  =      pipeline("""image-to-text"""      ,      model="""hf-internal-testing/tiny-random-BlipForConditionalGeneration"""      )
  			A							  =      """./tests/fixtures/tests_samples/COCO/000000039769.png"""
  			A							  =      """a photo of"""
  
  			A							  =      pipe(_lowerCAmelCase      ,      prompt=_lowerCAmelCase      )
  			self.assertTrue(outputs[0]["""generated_text"""].startswith(_lowerCAmelCase      )      )
  
  
  
  
  
  
  
  		@slow
  		@require_torch
  		def        A     (self						:      List[Any]      ):
  			A							  =      pipeline("""image-to-text"""      ,      model="""ydshieh/vit-gpt2-coco-en"""      )
  			A							  =      """./tests/fixtures/tests_samples/COCO/000000039769.png"""
  
  			A							  =      pipe(_lowerCAmelCase      )
  			self.assertEqual(_lowerCAmelCase      ,      [{"""generated_text""": """a cat laying on a blanket next to a cat laying on a bed """}]      )
  
  			A							  =      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						:      Optional[Any]      ):
  			A							  =      pipeline("""image-to-text"""      ,      model="""Salesforce/blip-image-captioning-base"""      )
  			A							  =      """https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png"""
  			A							  =      Image.open(requests.get(_lowerCAmelCase      ,      stream=_lowerCAmelCase      ).raw      )
  
  			A							  =      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]      ):
  			A							  =      pipeline("""image-to-text"""      ,      model="""microsoft/git-base-coco"""      )
  			A							  =      """https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png"""
  			A							  =      Image.open(requests.get(_lowerCAmelCase      ,      stream=_lowerCAmelCase      ).raw      )
  
  			A							  =      pipe(_lowerCAmelCase      )
  			self.assertEqual(_lowerCAmelCase      ,      [{"""generated_text""": """a cartoon of a purple character."""}]      )
  
  
  
  
  
  
  
  		@slow
  		@require_torch
  		def        A     (self						:      str      ):
  			A							  =      pipeline("""image-to-text"""      ,      model="""Salesforce/blip-image-captioning-base"""      )
  			A							  =      """https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg"""
  			A							  =      Image.open(requests.get(_lowerCAmelCase      ,      stream=_lowerCAmelCase      ).raw      )
  
  			A							  =      """a photography of"""
  
  			A							  =      pipe(_lowerCAmelCase      ,      prompt=_lowerCAmelCase      )
  			self.assertEqual(_lowerCAmelCase      ,      [{"""generated_text""": """a photography of a volcano"""}]      )
  
  			with self.assertRaises(_lowerCAmelCase      ):
  				A							  =      pipe([image, image]      ,      prompt=[prompt, prompt]      )
  
  
  
  
  
  
  
  		@slow
  		@require_torch
  		def        A     (self						:      Optional[int]      ):
  			A							  =      pipeline("""image-to-text"""      ,      model="""microsoft/git-base-coco"""      )
  			A							  =      """https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg"""
  			A							  =      Image.open(requests.get(_lowerCAmelCase      ,      stream=_lowerCAmelCase      ).raw      )
  
  			A							  =      """a photo of a"""
  
  			A							  =      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      ):
  				A							  =      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						:      Optional[Any]      ):
  			A							  =      pipeline("""image-to-text"""      ,      model="""google/pix2struct-ai2d-base"""      )
  			A							  =      """https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg"""
  			A							  =      Image.open(requests.get(_lowerCAmelCase      ,      stream=_lowerCAmelCase      ).raw      )
  
  			A							  =      """What does the label 15 represent? (1) lava (2) core (3) tunnel (4) ash cloud"""
  
  			A							  =      pipe(_lowerCAmelCase      ,      prompt=_lowerCAmelCase      )
  			self.assertEqual(_lowerCAmelCase      ,      [{"""generated_text""": """ash cloud"""}]      )
  
  			with self.assertRaises(_lowerCAmelCase      ):
  				A							  =      pipe([image, image]      ,      prompt=[prompt, prompt]      )
  
  
  
  
  
  
  
  		@slow
  		@require_tf
  		def        A     (self						:      str      ):
  			A							  =      pipeline("""image-to-text"""      ,      model="""ydshieh/vit-gpt2-coco-en"""      ,      framework="""tf"""      )
  			A							  =      """./tests/fixtures/tests_samples/COCO/000000039769.png"""
  
  			A							  =      pipe(_lowerCAmelCase      )
  			self.assertEqual(_lowerCAmelCase      ,      [{"""generated_text""": """a cat laying on a blanket next to a cat laying on a bed """}]      )
  
  			A							  =      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 """}],
  			    ]      ,      )
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  import logging
  import random
  
  import ray
  
  from transformers import RagConfig, RagRetriever, RagTokenizer
  from transformers.models.rag.retrieval_rag import CustomHFIndex
  
  
  _lowerCamelCase				:	Tuple				    =       logging.getLogger(__name__)
  
  
  
  class 							__UpperCAmelCase  :
  
  
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		def __init__(self						:      Union[str, Any]      ):
  			A							  =      False
  
  
  
  
  
  
  
  		def        A     (self						:      Any      ,      _lowerCAmelCase						:      str      ,      _lowerCAmelCase						:      List[str]      ,      _lowerCAmelCase						:      str      ,      _lowerCAmelCase						:      Any      ):
  			if not self.initialized:
  				A							  =      RagRetriever(
  				    _lowerCAmelCase      ,      question_encoder_tokenizer=_lowerCAmelCase      ,      generator_tokenizer=_lowerCAmelCase      ,      index=_lowerCAmelCase      ,      init_retrieval=_lowerCAmelCase      ,      )
  				A							  =      True
  
  
  
  
  
  
  
  		def        A     (self						:      Optional[int]      ):
  			self.retriever.index.init_index()
  
  
  
  
  
  
  
  		def        A     (self						:      Optional[int]      ):
  			# delete the old self.retriever object before assigning the new index
  			del self.retriever
  			A							  =      False
  
  
  
  
  
  
  
  		def        A     (self						:      List[str]      ,      _lowerCAmelCase						:      int      ,      _lowerCAmelCase						:      List[str]      ):
  			A  ,    A							  =      self.retriever._main_retrieve(_lowerCAmelCase      ,      _lowerCAmelCase      )
  			A							  =      self.retriever.index.get_doc_dicts(_lowerCAmelCase      )
  			return doc_ids, retrieved_doc_embeds, doc_dicts
  
  
  
  
  
  
  class 							__UpperCAmelCase  (       A__						):
  
  
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		def __init__(self						:      Tuple      ,      _lowerCAmelCase						:      int      ,      _lowerCAmelCase						:      int      ,      _lowerCAmelCase						:      List[str]      ,      _lowerCAmelCase						:      Tuple      ,      _lowerCAmelCase						:      str=None      ):
  			if index is not None and index.is_initialized() and len(_lowerCAmelCase      ) > 0:
  				raise ValueError(
  				    """When using Ray for distributed fine-tuning, """
  				    """you'll need to provide the paths instead, """
  				    """as the dataset and the index are loaded """
  				    """separately. More info in examples/rag/use_own_knowledge_dataset.py """      )
  
  			super().__init__(
  			    _lowerCAmelCase      ,      question_encoder_tokenizer=_lowerCAmelCase      ,      generator_tokenizer=_lowerCAmelCase      ,      index=_lowerCAmelCase      ,      init_retrieval=_lowerCAmelCase      ,      )
  
  			A							  =      retrieval_workers
  			A							  =      question_encoder_tokenizer
  			A							  =      generator_tokenizer
  			if len(self.retrieval_workers      ) > 0:
  				ray.get(
  				    [
  				        worker.create_rag_retriever.remote(_lowerCAmelCase      ,      _lowerCAmelCase      ,      _lowerCAmelCase      ,      _lowerCAmelCase      )
  				        for worker in self.retrieval_workers
  				    ]      )
  
  
  
  
  
  
  
  		def        A     (self						:      List[Any]      ):
  			logger.info("""initializing retrieval"""      )
  
  			if len(self.retrieval_workers      ) > 0:
  				ray.get([worker.init_retrieval.remote() for worker in self.retrieval_workers]      )
  			else:
  				# Non-distributed training. Load index into this same process.
  				self.index.init_index()
  
  
  
  
  
  
  
  		def        A     (self						:      str      ,      _lowerCAmelCase						:      Dict      ,      _lowerCAmelCase						:      Tuple      ):
  			if len(self.retrieval_workers      ) > 0:
  				# Select a random retrieval actor.
  				A							  =      self.retrieval_workers[random.randint(0      ,      len(self.retrieval_workers      ) - 1      )]
  				A  ,    A  ,    A							  =      ray.get(
  				    random_worker.retrieve.remote(_lowerCAmelCase      ,      _lowerCAmelCase      )      )
  			else:
  				A  ,    A							  =      self._main_retrieve(_lowerCAmelCase      ,      _lowerCAmelCase      )
  				A							  =      self.index.get_doc_dicts(_lowerCAmelCase      )
  			return retrieved_doc_embeds, doc_ids, doc_dicts
  
  
  
  
  
  
  
  		@classmethod
  		def        A     (cls						:      Union[str, Any]      ,      _lowerCAmelCase						:      int      ,      _lowerCAmelCase						:      Optional[Any]=None      ,      **_lowerCAmelCase						:      Union[str, Any]      ):
  			return super(_lowerCAmelCase      ,      cls      ).get_tokenizers(_lowerCAmelCase      ,      _lowerCAmelCase      ,      **_lowerCAmelCase      )
  
  
  
  
  
  
  
  		@classmethod
  		def        A     (cls						:      List[Any]      ,      _lowerCAmelCase						:      Optional[int]      ,      _lowerCAmelCase						:      List[str]      ,      _lowerCAmelCase						:      str=None      ,      **_lowerCAmelCase						:      List[str]      ):
  			A							  =      kwargs.pop("""config"""      ,      _lowerCAmelCase      ) or RagConfig.from_pretrained(_lowerCAmelCase      ,      **_lowerCAmelCase      )
  			A							  =      RagTokenizer.from_pretrained(_lowerCAmelCase      ,      config=_lowerCAmelCase      )
  			A							  =      rag_tokenizer.question_encoder
  			A							  =      rag_tokenizer.generator
  
  			if indexed_dataset is not None:
  				A							  =      """custom"""
  				A							  =      CustomHFIndex(config.retrieval_vector_size      ,      _lowerCAmelCase      )
  			else:
  				A							  =      cls._build_index(_lowerCAmelCase      )
  
  			return cls(
  			    _lowerCAmelCase      ,      question_encoder_tokenizer=_lowerCAmelCase      ,      generator_tokenizer=_lowerCAmelCase      ,      retrieval_workers=_lowerCAmelCase      ,      index=_lowerCAmelCase      ,      )
  
  
  
  
  
  
  
  		def        A     (self						:      List[Any]      ):
  			logger.info("""re-loading the new dataset with embeddings"""      )
  			# access from the training loop
  
  			ray.get([worker.clear_object.remote() for worker in self.retrieval_workers]      )
  
  			# build the index object again
  			A							  =      self._build_index(self.config      )
  
  			ray.get(
  			    [
  			        worker.create_rag_retriever.remote(
  			            self.config      ,      self.question_encoder_tokenizer      ,      self.generator_tokenizer      ,      _lowerCAmelCase      )
  			        for worker in self.retrieval_workers
  			    ]      )
  
  