code: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  from collections import OrderedDict
  from typing import Mapping
  
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxConfig
  from ...utils import logging
  
  
  lowercase__			=	logging.get_logger(__name__)
  
  lowercase__			=	{
      '''flaubert/flaubert_small_cased''': '''https://huggingface.co/flaubert/flaubert_small_cased/resolve/main/config.json''',
      '''flaubert/flaubert_base_uncased''': '''https://huggingface.co/flaubert/flaubert_base_uncased/resolve/main/config.json''',
      '''flaubert/flaubert_base_cased''': '''https://huggingface.co/flaubert/flaubert_base_cased/resolve/main/config.json''',
      '''flaubert/flaubert_large_cased''': '''https://huggingface.co/flaubert/flaubert_large_cased/resolve/main/config.json''',
  }
  
  
  
  
  
  
  class 						lowercase     (   UpperCAmelCase_):
        __lowercase 		=  '''flaubert'''
        __lowercase 		=  {
            '''hidden_size''': '''emb_dim''',
            '''num_attention_heads''': '''n_heads''',
            '''num_hidden_layers''': '''n_layers''',
            '''n_words''': '''vocab_size''',  # For backward compatibility
        }
  
  
  
  
  
  
        def __init__(self ,  a__=False ,  a__=0.0 ,  a__=3_0_1_4_5 ,  a__=2_0_4_8 ,  a__=1_2 ,  a__=1_6 ,  a__=0.1 ,  a__=0.1 ,  a__=True ,  a__=False ,  a__=False ,  a__=False ,  a__=1 ,  a__=True ,  a__=5_1_2 ,  a__=2_0_4_8**-0.5 ,  a__=1E-12 ,  a__=0.02 ,  a__=0 ,  a__=1 ,  a__=2 ,  a__=3 ,  a__=5 ,  a__=True ,  a__="first" ,  a__=True ,  a__=None ,  a__=True ,  a__=0.1 ,  a__=5 ,  a__=5 ,  a__=0 ,  a__=0 ,  a__=2 ,  a__=0 ,  **a__ ,  )       ->   Optional[Any]:
           SCREAMING_SNAKE_CASE__			:				Dict       						= pre_norm
           SCREAMING_SNAKE_CASE__			:				Any       						= layerdrop
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= vocab_size
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= emb_dim
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= n_layers
           SCREAMING_SNAKE_CASE__			:				Dict       						= n_heads
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= dropout
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= attention_dropout
           SCREAMING_SNAKE_CASE__			:				str       						= gelu_activation
           SCREAMING_SNAKE_CASE__			:				List[str]       						= sinusoidal_embeddings
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= causal
           SCREAMING_SNAKE_CASE__			:				List[str]       						= asm
           SCREAMING_SNAKE_CASE__			:				Any       						= n_langs
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= use_lang_emb
           SCREAMING_SNAKE_CASE__			:				int       						= layer_norm_eps
           SCREAMING_SNAKE_CASE__			:				Dict       						= bos_index
           SCREAMING_SNAKE_CASE__			:				List[str]       						= eos_index
           SCREAMING_SNAKE_CASE__			:				Dict       						= pad_index
           SCREAMING_SNAKE_CASE__			:				str       						= unk_index
           SCREAMING_SNAKE_CASE__			:				Dict       						= mask_index
           SCREAMING_SNAKE_CASE__			:				str       						= is_encoder
           SCREAMING_SNAKE_CASE__			:				int       						= max_position_embeddings
           SCREAMING_SNAKE_CASE__			:				List[str]       						= embed_init_std
           SCREAMING_SNAKE_CASE__			:				List[str]       						= init_std
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= summary_type
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= summary_use_proj
           SCREAMING_SNAKE_CASE__			:				List[str]       						= summary_activation
           SCREAMING_SNAKE_CASE__			:				int       						= summary_proj_to_labels
           SCREAMING_SNAKE_CASE__			:				int       						= summary_first_dropout
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= start_n_top
           SCREAMING_SNAKE_CASE__			:				int       						= end_n_top
           SCREAMING_SNAKE_CASE__			:				Any       						= mask_token_id
           SCREAMING_SNAKE_CASE__			:				Dict       						= lang_id
  
           if "n_words" in kwargs:
              SCREAMING_SNAKE_CASE__			:				List[Any]       						= kwargs['''n_words''']
  
           super().__init__(pad_token_id=a__ ,  bos_token_id=a__ ,  **a__					)
  
  
  
  
  
  
  class 						lowercase     (   UpperCAmelCase_):
  
  
  
  
  
  
        @property
        def    A__(self					)       ->   Mapping[str, Mapping[int, str]]:
           if self.task == "multiple-choice":
              SCREAMING_SNAKE_CASE__			:				int       						= {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
           else:
              SCREAMING_SNAKE_CASE__			:				int       						= {0: '''batch''', 1: '''sequence'''}
           return OrderedDict(
               [
                   ('''input_ids''', dynamic_axis),
                   ('''attention_mask''', dynamic_axis),
               ]					)
  
  
style_context: 
  
  
  
  
  '''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:
         lowercase__			=	False
  
  
  if is_vision_available():
         from PIL import Image
  else:
  
  
  
  
  
  
         class 						lowercase     :
  
  
  
  
  
  
               @staticmethod
               def    A__(*a__ ,  **a__					)       ->   Optional[Any]:
                  pass
  
  
  
  
  
  
  @is_pipeline_test
  @require_vision
  class 						lowercase     (   unittest.TestCase):
        __lowercase 		=  MODEL_FOR_VISION_2_SEQ_MAPPING
        __lowercase 		=  TF_MODEL_FOR_VISION_2_SEQ_MAPPING
  
  
  
  
  
  
        def    A__(self ,  a__ ,  a__ ,  a__					)       ->   Optional[Any]:
           SCREAMING_SNAKE_CASE__			:				Tuple       						= pipeline('''image-to-text''' ,  model=a__ ,  tokenizer=a__ ,  image_processor=a__					)
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= [
               Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					),
               '''./tests/fixtures/tests_samples/COCO/000000039769.png''',
           ]
           return pipe, examples
  
  
  
  
  
  
        def    A__(self ,  a__ ,  a__					)       ->   Any:
           SCREAMING_SNAKE_CASE__			:				Tuple       						= pipe(a__					)
           self.assertEqual(
               a__ ,  [
                   [{'''generated_text''': ANY(a__					)}],
                   [{'''generated_text''': ANY(a__					)}],
               ] ,  )
  
  
  
  
  
  
        @require_tf
        def    A__(self					)       ->   List[str]:
           SCREAMING_SNAKE_CASE__			:				List[str]       						= pipeline('''image-to-text''' ,  model='''hf-internal-testing/tiny-random-vit-gpt2''' ,  framework='''tf'''					)
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
  
           SCREAMING_SNAKE_CASE__			:				str       						= pipe(a__					)
           self.assertEqual(
               a__ ,  [
                   {
                       '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                   },
               ] ,  )
  
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= pipe([image, image]					)
           self.assertEqual(
               a__ ,  [
                   [
                       {
                           '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                       }
                   ],
                   [
                       {
                           '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                       }
                   ],
               ] ,  )
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipe(a__ ,  max_new_tokens=1					)
           self.assertEqual(
               a__ ,  [{'''generated_text''': '''growth'''}] ,  )
  
  
  
  
  
  
        @require_torch
        def    A__(self					)       ->   Optional[Any]:
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= pipeline('''image-to-text''' ,  model='''hf-internal-testing/tiny-random-vit-gpt2'''					)
           SCREAMING_SNAKE_CASE__			:				Any       						= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
  
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= pipe(a__					)
           self.assertEqual(
               a__ ,  [
                   {
                       '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                   },
               ] ,  )
  
           SCREAMING_SNAKE_CASE__			:				Any       						= pipe([image, image]					)
           self.assertEqual(
               a__ ,  [
                   [
                       {
                           '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                       }
                   ],
                   [
                       {
                           '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                       }
                   ],
               ] ,  )
  
  
  
  
  
  
        @require_torch
        def    A__(self					)       ->   Any:
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipeline('''image-to-text''' ,  model='''hf-internal-testing/tiny-random-BlipForConditionalGeneration'''					)
           SCREAMING_SNAKE_CASE__			:				int       						= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
           SCREAMING_SNAKE_CASE__			:				Tuple       						= '''a photo of'''
  
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= pipe(a__ ,  prompt=a__					)
           self.assertTrue(outputs[0]['''generated_text'''].startswith(a__					)					)
  
  
  
  
  
  
        @slow
        @require_torch
        def    A__(self					)       ->   List[Any]:
           SCREAMING_SNAKE_CASE__			:				Tuple       						= pipeline('''image-to-text''' ,  model='''ydshieh/vit-gpt2-coco-en'''					)
           SCREAMING_SNAKE_CASE__			:				List[str]       						= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
  
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= pipe(a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a cat laying on a blanket next to a cat laying on a bed '''}]					)
  
           SCREAMING_SNAKE_CASE__			:				Tuple       						= pipe([image, image]					)
           self.assertEqual(
               a__ ,  [
                   [{'''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					)       ->   Tuple:
           SCREAMING_SNAKE_CASE__			:				Dict       						= pipeline('''image-to-text''' ,  model='''Salesforce/blip-image-captioning-base'''					)
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= '''https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'''
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= Image.open(requests.get(a__ ,  stream=a__					).raw					)
  
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= pipe(a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a pink pokemon pokemon with a blue shirt and a blue shirt'''}]					)
  
  
  
  
  
  
        @slow
        @require_torch
        def    A__(self					)       ->   int:
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= pipeline('''image-to-text''' ,  model='''microsoft/git-base-coco'''					)
           SCREAMING_SNAKE_CASE__			:				str       						= '''https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'''
           SCREAMING_SNAKE_CASE__			:				List[str]       						= Image.open(requests.get(a__ ,  stream=a__					).raw					)
  
           SCREAMING_SNAKE_CASE__			:				str       						= pipe(a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a cartoon of a purple character.'''}]					)
  
  
  
  
  
  
        @slow
        @require_torch
        def    A__(self					)       ->   Dict:
           SCREAMING_SNAKE_CASE__			:				str       						= pipeline('''image-to-text''' ,  model='''Salesforce/blip-image-captioning-base'''					)
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= '''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'''
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= Image.open(requests.get(a__ ,  stream=a__					).raw					)
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= '''a photography of'''
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipe(a__ ,  prompt=a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a photography of a volcano'''}]					)
  
           with self.assertRaises(a__					):
              SCREAMING_SNAKE_CASE__			:				Any       						= pipe([image, image] ,  prompt=[prompt, prompt]					)
  
  
  
  
  
  
        @slow
        @require_torch
        def    A__(self					)       ->   Dict:
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipeline('''image-to-text''' ,  model='''microsoft/git-base-coco'''					)
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= '''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'''
           SCREAMING_SNAKE_CASE__			:				Dict       						= Image.open(requests.get(a__ ,  stream=a__					).raw					)
  
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= '''a photo of a'''
  
           SCREAMING_SNAKE_CASE__			:				str       						= pipe(a__ ,  prompt=a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a photo of a tent with a tent and a tent in the background.'''}]					)
  
           with self.assertRaises(a__					):
              SCREAMING_SNAKE_CASE__			:				Dict       						= 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					)       ->   Union[str, Any]:
           SCREAMING_SNAKE_CASE__			:				List[str]       						= pipeline('''image-to-text''' ,  model='''google/pix2struct-ai2d-base'''					)
           SCREAMING_SNAKE_CASE__			:				int       						= '''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'''
           SCREAMING_SNAKE_CASE__			:				Any       						= Image.open(requests.get(a__ ,  stream=a__					).raw					)
  
           SCREAMING_SNAKE_CASE__			:				int       						= '''What does the label 15 represent? (1) lava (2) core (3) tunnel (4) ash cloud'''
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipe(a__ ,  prompt=a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''ash cloud'''}]					)
  
           with self.assertRaises(a__					):
              SCREAMING_SNAKE_CASE__			:				Any       						= pipe([image, image] ,  prompt=[prompt, prompt]					)
  
  
  
  
  
  
        @slow
        @require_tf
        def    A__(self					)       ->   str:
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= pipeline('''image-to-text''' ,  model='''ydshieh/vit-gpt2-coco-en''' ,  framework='''tf'''					)
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
  
           SCREAMING_SNAKE_CASE__			:				Dict       						= pipe(a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a cat laying on a blanket next to a cat laying on a bed '''}]					)
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipe([image, image]					)
           self.assertEqual(
               a__ ,  [
                   [{'''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 '''}],
               ] ,  )
  
  