code: 
  
  
  
  
  
  import os
  import sys
  from pathlib import Path
  
  import torch
  
  from transformers.testing_utils import TestCasePlus, execute_subprocess_async, require_torch_multi_gpu
  from utils import load_json
  
  
  _lowercase		:     List[str] 					=torch.cuda.is_available()
  _lowercase		:     List[str] 					=[""" Sam ate lunch today.""", """Sams lunch ingredients."""]
  _lowercase		:     str 					=["""A very interesting story about what I ate for lunch.""", """Avocado, celery, turkey, coffee"""]
  _lowercase		:     str 					={
      """max_tokens_per_batch""": None,
      """supervise_forward""": True,
      """normalize_hidden""": True,
      """label_smoothing""": 0.2,
      """eval_max_gen_length""": None,
      """eval_beams""": 1,
      """val_metric""": """loss""",
      """save_top_k""": 1,
      """adafactor""": True,
      """early_stopping_patience""": 2,
      """logger_name""": """default""",
      """length_penalty""": 0.5,
      """cache_dir""": """""",
      """task""": """summarization""",
      """num_workers""": 2,
      """alpha_hid""": 0,
      """freeze_embeds""": True,
      """enc_only""": False,
      """tgt_suffix""": """""",
      """resume_from_checkpoint""": None,
      """sortish_sampler""": True,
      """student_decoder_layers""": 1,
      """val_check_interval""": 1.0,
      """output_dir""": """""",
      """fp16""": False,  # TODO(SS): set this to CUDA_AVAILABLE if ci installs apex or start using native amp
      """no_teacher""": False,
      """fp16_opt_level""": """O1""",
      """gpus""": 1 if CUDA_AVAILABLE else 0,
      """n_tpu_cores""": 0,
      """max_grad_norm""": 1.0,
      """do_train""": True,
      """do_predict""": True,
      """accumulate_grad_batches""": 1,
      """server_ip""": """""",
      """server_port""": """""",
      """seed""": 42,
      """model_name_or_path""": """sshleifer/bart-tiny-random""",
      """config_name""": """""",
      """tokenizer_name""": """facebook/bart-large""",
      """do_lower_case""": False,
      """learning_rate""": 0.3,
      """lr_scheduler""": """linear""",
      """weight_decay""": 0.0,
      """adam_epsilon""": 1e-08,
      """warmup_steps""": 0,
      """max_epochs""": 1,
      """train_batch_size""": 2,
      """eval_batch_size""": 2,
      """max_source_length""": 12,
      """max_target_length""": 12,
      """val_max_target_length""": 12,
      """test_max_target_length""": 12,
      """fast_dev_run""": False,
      """no_cache""": False,
      """n_train""": -1,
      """n_val""": -1,
      """n_test""": -1,
      """student_encoder_layers""": 1,
      """freeze_encoder""": False,
      """auto_scale_batch_size""": False,
      """overwrite_output_dir""": False,
      """student""": None,
  }
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
  		lowerCamelCase_  :    Dict   	=			'\n'.join(lowerCAmelCase__	)
  		Path(lowerCAmelCase__	).open('w'	).writelines(lowerCAmelCase__	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
  		for split in ["train", "val", "test"]:
  				_dump_articles(os.path.join(lowerCAmelCase__       ,F"{split}.source"	)       ,lowerCAmelCase__	)
  				_dump_articles(os.path.join(lowerCAmelCase__       ,F"{split}.target"	)       ,lowerCAmelCase__	)
  		return tmp_dir
  
  
  
  
  
  
  class 	UpperCamelCase_     (     snake_case__       ):
  
  
  
  					@classmethod
  					def      __a    (		cls    :    List[str]	):
  							return cls
  
  
  
  					@require_torch_multi_gpu
  					def      __a    (		self    :    List[Any]	):
  							lowerCamelCase_  :    Tuple   	=			{
  							    'no_teacher': True,
  							    'freeze_encoder': True,
  							    'gpus': 2,
  							    'overwrite_output_dir': True,
  							    'sortish_sampler': True,
  							}
  							self._test_distiller_cli_fork(lowerCamelCase					,			check_contents=lowerCamelCase	)
  
  
  
  
  
  					def      __a    (		self    :    Optional[int]					,			lowerCamelCase    :    Tuple					,			lowerCamelCase    :    Any=True	):
  							lowerCamelCase_  :    Any   	=			{
  							    'label_smoothing': 0.0,
  							    'early_stopping_patience': -1,
  							    'train_batch_size': 1,
  							    'eval_batch_size': 2,
  							    'max_epochs': 2,
  							    'alpha_mlm': 0.2,
  							    'alpha_ce': 0.8,
  							    'do_predict': True,
  							    'model_name_or_path': 'sshleifer/tinier_bart',
  							    'teacher': CHEAP_ARGS['model_name_or_path'],
  							    'val_check_interval': 0.5,
  							}
  							default_updates.update(lowerCamelCase	)
  							lowerCamelCase_  :    dict   	=			CHEAP_ARGS.copy()
  							lowerCamelCase_  :    Optional[Any]   	=			make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()	)
  							lowerCamelCase_  :    Union[str, Any]   	=			self.get_auto_remove_tmp_dir()
  							args_d.update(data_dir=lowerCamelCase					,			output_dir=lowerCamelCase					,			**lowerCamelCase	)
  
  							def convert(lowerCamelCase    :    Optional[Any]					,			lowerCamelCase    :    Optional[int]	):
  									if k in ["tgt_suffix", "server_ip", "server_port", "out", "n_tpu_cores"]:
  											return ""
  									if v is False or v is None:
  											return ""
  									if v is True:  # or len(str(v))==0:
  											return F"--{k}"
  									return F"--{k}={v}"
  
  							lowerCamelCase_  :    Union[str, Any]   	=			[x for x in (convert(lowerCamelCase					,			lowerCamelCase	) for k, v in args_d.items()) if len(lowerCamelCase	)]
  							lowerCamelCase_  :    List[Any]   	=			[sys.executable, F"{self.test_file_dir}/distillation.py"] + cli_args
  							execute_subprocess_async(lowerCamelCase					,			env=self.get_env()	)
  
  							lowerCamelCase_  :    Optional[int]   	=			os.listdir(lowerCamelCase	)
  							lowerCamelCase_  :    Tuple   	=			{os.path.basename(lowerCamelCase	) for p in contents}
  							lowerCamelCase_  :    int   	=			[p for p in contents if p.endswith('ckpt'	)]
  							assert len(lowerCamelCase	) > 0
  
  							self.assertIn('test_generations.txt'					,			lowerCamelCase	)
  							self.assertIn('test_results.txt'					,			lowerCamelCase	)
  
  							# get the following from the module, (we don't have access to `model` here)
  							lowerCamelCase_  :    Any   	=			os.path.join(lowerCamelCase					,			'metrics.json'	)
  							lowerCamelCase_  :    Union[str, Any]   	=			'rouge2'
  
  							lowerCamelCase_  :    int   	=			load_json(lowerCamelCase	)
  							# {'test': [{'test_avg_loss': 10.63731575012207, 'test_avg_rouge1': 0.0, 'test_avg_rouge2': 0.0, 'test_avg_rougeL': 0.0, 'test_avg_gen_time': 0.1822289228439331, 'test_avg_gen_len': 142.0, 'step_count': 1}]}
  							print(lowerCamelCase	)
  							lowerCamelCase_  :    List[str]   	=			metrics['val'][-1]
  							self.assertGreaterEqual(last_step_stats['val_avg_gen_time']					,			0.01	)
  							self.assertIsInstance(last_step_stats[F"val_avg_{val_metric}"]					,			lowerCamelCase	)
  							self.assertEqual(len(metrics['test']	)					,			1	)
  							lowerCamelCase_  :    Dict   	=			int(args_d['max_epochs'] * (1 / args_d['val_check_interval']) / 2 + 1	)
  							self.assertEqual(len(metrics['val']	)					,			lowerCamelCase	)
  
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 '}],
  							    ]					,			)
  