

'''simple docstring'''



import json
import logging
import os
import sys
from pathlib import Path

import finetune_rag

from transformers.file_utils import is_apex_available
from transformers.testing_utils import (
    TestCasePlus,
    execute_subprocess_async,
    require_ray,
    require_torch_gpu,
    require_torch_multi_gpu,
)


logging.basicConfig(level=logging.DEBUG)
_UpperCamelCase						:  int							       =				logging.getLogger()

_UpperCamelCase						:  int							       =				logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)



class 				_snake_case					(   a_			):

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      os.makedirs(_SCREAMING_SNAKE_CASE      , exist_ok=_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							{'source': 'What is love ?', 'target': 'life'}
      lowerCAmelCase 						=							{'train': 12, 'val': 2, 'test': 2}
      for split in ["train", "test", "val"]:
          for field in ["source", "target"]:
              lowerCAmelCase 						=							'\n'.join([contents[field]] * n_lines[split]	)
              with open(os.path.join(_SCREAMING_SNAKE_CASE      , F'{split}.{field}'	)      , 'w'	) as f:
                  f.write(_SCREAMING_SNAKE_CASE	)

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE = "pytorch"	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.get_auto_remove_tmp_dir()
      lowerCAmelCase 						=							os.path.join(_SCREAMING_SNAKE_CASE      , 'output'	)
      lowerCAmelCase 						=							os.path.join(_SCREAMING_SNAKE_CASE      , 'data'	)
      self._create_dummy_data(data_dir=_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							F'\n                --data_dir {data_dir} \\n                --output_dir {output_dir} \\n                --model_name_or_path facebook/rag-sequence-base \\n                --model_type rag_sequence \\n                --do_train \\n                --do_predict \\n                --n_val -1 \\n                --val_check_interval 1.0 \\n                --train_batch_size 2 \\n                --eval_batch_size 1 \\n                --max_source_length 25 \\n                --max_target_length 25 \\n                --val_max_target_length 25 \\n                --test_max_target_length 25 \\n                --label_smoothing 0.1 \\n                --dropout 0.1 \\n                --attention_dropout 0.1 \\n                --weight_decay 0.001 \\n                --adam_epsilon 1e-08 \\n                --max_grad_norm 0.1 \\n                --lr_scheduler polynomial \\n                --learning_rate 3e-04 \\n                --num_train_epochs 1 \\n                --warmup_steps 4 \\n                --gradient_accumulation_steps 1 \\n                --distributed-port 8787 \\n                --use_dummy_dataset 1 \\n                --distributed_retriever {distributed_retriever} \\n            '.split()

      if gpus > 0:
          testargs.append(F'--gpus={gpus}'	)
          if is_apex_available():
              testargs.append('--fp16'	)
      else:
          testargs.append('--gpus=0'	)
          testargs.append('--distributed_backend=ddp_cpu'	)
          testargs.append('--num_processes=2'	)

      lowerCAmelCase 						=							[sys.executable, str(Path(finetune_rag.__file__	).resolve()	)] + testargs
      execute_subprocess_async(_SCREAMING_SNAKE_CASE      , env=self.get_env()	)

      lowerCAmelCase 						=							os.path.join(_SCREAMING_SNAKE_CASE      , 'metrics.json'	)
      with open(_SCREAMING_SNAKE_CASE	) as f:
          lowerCAmelCase 						=							json.load(_SCREAMING_SNAKE_CASE	)
      return result

  @require_torch_gpu
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self._run_finetune(gpus=1	)
      self.assertGreaterEqual(result['test'][0]['test_avg_em']      , 0.2	)

  @require_torch_multi_gpu
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self._run_finetune(gpus=2	)
      self.assertGreaterEqual(result['test'][0]['test_avg_em']      , 0.2	)

  @require_torch_gpu
  @require_ray
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self._run_finetune(gpus=1      , distributed_retriever='ray'	)
      self.assertGreaterEqual(result['test'][0]['test_avg_em']      , 0.2	)


  @require_torch_multi_gpu
  @require_ray
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self._run_finetune(gpus=1      , distributed_retriever='ray'	)
      self.assertGreaterEqual(result['test'][0]['test_avg_em']      , 0.2	)








'''simple docstring'''



from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
     from PIL import Image

     from ..image_utils import load_image

if is_tf_available():
     import tensorflow as tf

     from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
     from ..tf_utils import stable_softmax

if is_torch_available():
     from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING

_UpperCamelCase						:  Optional[int]							       =				logging.get_logger(__name__)



@add_end_docstrings(a_			)
class 				_snake_case					(   a_			):

  def __init__(				self      , *_SCREAMING_SNAKE_CASE      , **_SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      super().__init__(*_SCREAMING_SNAKE_CASE      , **_SCREAMING_SNAKE_CASE	)
      requires_backends(self      , 'vision'	)
      self.check_model_type(
          TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
          if self.framework == 'tf'
          else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING	)

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE=None	):





      '''simple docstring'''

      lowerCAmelCase 						=							{}
      if top_k is not None:
          lowerCAmelCase 						=							top_k
      return {}, {}, postprocess_params

  def __call__(				self      , _SCREAMING_SNAKE_CASE      , **_SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      return super().__call__(_SCREAMING_SNAKE_CASE      , **_SCREAMING_SNAKE_CASE	)

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      lowerCAmelCase 						=							load_image(_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							self.image_processor(images=_SCREAMING_SNAKE_CASE      , return_tensors=self.framework	)
      return model_inputs

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.model(**_SCREAMING_SNAKE_CASE	)
      return model_outputs


  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE=5	):





      '''simple docstring'''

      if top_k > self.model.config.num_labels:
          lowerCAmelCase 						=							self.model.config.num_labels

      if self.framework == "pt":
          lowerCAmelCase 						=							model_outputs.logits.softmax(-1	)[0]
          lowerCAmelCase						,   lowerCAmelCase 						=							probs.topk(_SCREAMING_SNAKE_CASE	)
      elif self.framework == "tf":
          lowerCAmelCase 						=							stable_softmax(model_outputs.logits      , axis=-1	)[0]
          lowerCAmelCase 						=							tf.math.top_k(_SCREAMING_SNAKE_CASE      , k=_SCREAMING_SNAKE_CASE	)
          lowerCAmelCase						,   lowerCAmelCase 						=							topk.values.numpy(), topk.indices.numpy()
      else:
          raise ValueError(F'Unsupported framework: {self.framework}'	)

      lowerCAmelCase 						=							scores.tolist()
      lowerCAmelCase 						=							ids.tolist()
      return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	)]





