"""simple docstring"""
import argparse
import json
import logging
import os
import shutil
import sys
import tempfile
import unittest
from unittest import mock

import torch
from accelerate.utils import write_basic_config

from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device
from transformers.utils import is_apex_available


logging.basicConfig(level=logging.DEBUG)

lowercase__ :    Optional[Any] 	=     logging.getLogger()







def 						__a       (     )     ->Tuple:
  a__:					List[Any]      							=     argparse.ArgumentParser()
  parser.add_argument('-f'       )
  a__:					int      							=     parser.parse_args()
  return args.f







def 						__a       (     _SCREAMING_SNAKE_CASE       )     ->str:
  a__:					List[str]      							=     {}
  a__:					List[Any]      							=     os.path.join(_SCREAMING_SNAKE_CASE		,					'all_results.json'       )
  if os.path.exists(_SCREAMING_SNAKE_CASE       ):
    with open(_SCREAMING_SNAKE_CASE		,					'r'       ) as f:
      a__:					str      							=     json.load(_SCREAMING_SNAKE_CASE       )
  else:
    raise ValueError(F'can\'t find {path}'       )
  return results







def 						__a       (     )     ->Optional[Any]:
  a__:					Tuple      							=     torch.cuda.is_available() and torch_device == 'cuda'
  return is_using_cuda and is_apex_available()


lowercase__ :    Tuple 	=     logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)




class        __snake_case	(					__lowerCAmelCase    ):



      @classmethod
      def   lowerCamelCase_       (						cls)     ->      Tuple:





        '''simple docstring'''





        a__:					str      							=     tempfile.mkdtemp()
        a__:					Optional[Any]      							=     os.path.join(cls.tmpdir   ,      'default_config.yml')
        write_basic_config(save_location=cls.configPath)
        a__:					str      							=     ['accelerate', 'launch', '--config_file', cls.configPath]



      @classmethod
      def   lowerCamelCase_       (						cls)     ->      Optional[int]:





        '''simple docstring'''





        shutil.rmtree(cls.tmpdir)



      @mock.patch.dict(os.environ   ,      {'WANDB_MODE': 'offline'})
      def   lowerCamelCase_       (						self)     ->      Dict:





        '''simple docstring'''





        a__:					Dict      							=     self.get_auto_remove_tmp_dir()
        a__:					Tuple      							=     f'\n            {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py\n            --model_name_or_path distilbert-base-uncased\n            --output_dir {tmp_dir}\n            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv\n            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --learning_rate=1e-4\n            --seed=42\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

        if is_cuda_and_apex_available():
          testargs.append('--fp16')

        run_command(self._launch_args + testargs)
        a__:					Optional[int]      							=     get_results(lowercase)
        self.assertGreaterEqual(result['eval_accuracy']   ,      0.75)
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'epoch_0')))
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'glue_no_trainer')))



      @mock.patch.dict(os.environ   ,      {'WANDB_MODE': 'offline'})
      def   lowerCamelCase_       (						self)     ->      Union[str, Any]:





        '''simple docstring'''





        a__:					List[str]      							=     self.get_auto_remove_tmp_dir()
        a__:					Any      							=     f'\n            {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py\n            --model_name_or_path distilgpt2\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --block_size 128\n            --per_device_train_batch_size 5\n            --per_device_eval_batch_size 5\n            --num_train_epochs 2\n            --output_dir {tmp_dir}\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

        if torch.cuda.device_count() > 1:
          # Skipping because there are not enough batches to train the model + would need a drop_last to work.
          return

        run_command(self._launch_args + testargs)
        a__:					Union[str, Any]      							=     get_results(lowercase)
        self.assertLess(result['perplexity']   ,      1_00)
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'epoch_0')))
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'clm_no_trainer')))



      @mock.patch.dict(os.environ   ,      {'WANDB_MODE': 'offline'})
      def   lowerCamelCase_       (						self)     ->      int:





        '''simple docstring'''





        a__:					Optional[Any]      							=     self.get_auto_remove_tmp_dir()
        a__:					Optional[int]      							=     f'\n            {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py\n            --model_name_or_path distilroberta-base\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --output_dir {tmp_dir}\n            --num_train_epochs=1\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

        run_command(self._launch_args + testargs)
        a__:					Optional[Any]      							=     get_results(lowercase)
        self.assertLess(result['perplexity']   ,      42)
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'epoch_0')))
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'mlm_no_trainer')))



      @mock.patch.dict(os.environ   ,      {'WANDB_MODE': 'offline'})
      def   lowerCamelCase_       (						self)     ->      Dict:





        '''simple docstring'''





        a__:					List[Any]      							=     7 if get_gpu_count() > 1 else 2

        a__:					List[str]      							=     self.get_auto_remove_tmp_dir()
        a__:					Tuple      							=     f'\n            {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/conll/sample.json\n            --validation_file tests/fixtures/tests_samples/conll/sample.json\n            --output_dir {tmp_dir}\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=2\n            --num_train_epochs={epochs}\n            --seed 7\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

        run_command(self._launch_args + testargs)
        a__:					int      							=     get_results(lowercase)
        self.assertGreaterEqual(result['eval_accuracy']   ,      0.75)
        self.assertLess(result['train_loss']   ,      0.5)
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'epoch_0')))
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'ner_no_trainer')))



      @unittest.skip(reason='Fix me @muellerzr')
      @mock.patch.dict(os.environ   ,      {'WANDB_MODE': 'offline'})
      def   lowerCamelCase_       (						self)     ->      Dict:





        '''simple docstring'''





        a__:					List[Any]      							=     self.get_auto_remove_tmp_dir()
        a__:					Optional[int]      							=     f'\n            {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --version_2_with_negative\n            --train_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --output_dir {tmp_dir}\n            --seed=42\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

        run_command(self._launch_args + testargs)
        a__:					List[str]      							=     get_results(lowercase)
        # Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics.
        self.assertGreaterEqual(result['eval_f1']   ,      28)
        self.assertGreaterEqual(result['eval_exact']   ,      28)
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'epoch_0')))
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'qa_no_trainer')))



      @mock.patch.dict(os.environ   ,      {'WANDB_MODE': 'offline'})
      def   lowerCamelCase_       (						self)     ->      Union[str, Any]:





        '''simple docstring'''





        a__:					Dict      							=     self.get_auto_remove_tmp_dir()
        a__:					int      							=     f'\n            {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/swag/sample.json\n            --validation_file tests/fixtures/tests_samples/swag/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=20\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --with_tracking\n        '.split()

        run_command(self._launch_args + testargs)
        a__:					str      							=     get_results(lowercase)
        self.assertGreaterEqual(result['eval_accuracy']   ,      0.8)
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'swag_no_trainer')))



      @slow
      @mock.patch.dict(os.environ   ,      {'WANDB_MODE': 'offline'})
      def   lowerCamelCase_       (						self)     ->      Optional[Any]:





        '''simple docstring'''





        a__:					Optional[Any]      							=     self.get_auto_remove_tmp_dir()
        a__:					int      							=     f'\n            {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py\n            --model_name_or_path t5-small\n            --train_file tests/fixtures/tests_samples/xsum/sample.json\n            --validation_file tests/fixtures/tests_samples/xsum/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

        run_command(self._launch_args + testargs)
        a__:					Any      							=     get_results(lowercase)
        self.assertGreaterEqual(result['eval_rouge1']   ,      10)
        self.assertGreaterEqual(result['eval_rouge2']   ,      2)
        self.assertGreaterEqual(result['eval_rougeL']   ,      7)
        self.assertGreaterEqual(result['eval_rougeLsum']   ,      7)
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'epoch_0')))
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'summarization_no_trainer')))



      @slow
      @mock.patch.dict(os.environ   ,      {'WANDB_MODE': 'offline'})
      def   lowerCamelCase_       (						self)     ->      Tuple:





        '''simple docstring'''





        a__:					List[Any]      							=     self.get_auto_remove_tmp_dir()
        a__:					Any      							=     f'\n            {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py\n            --model_name_or_path sshleifer/student_marian_en_ro_6_1\n            --source_lang en\n            --target_lang ro\n            --train_file tests/fixtures/tests_samples/wmt16/sample.json\n            --validation_file tests/fixtures/tests_samples/wmt16/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --num_beams=6\n            --learning_rate=3e-3\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --source_lang en_XX\n            --target_lang ro_RO\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

        run_command(self._launch_args + testargs)
        a__:					int      							=     get_results(lowercase)
        self.assertGreaterEqual(result['eval_bleu']   ,      30)
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'epoch_0')))
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'translation_no_trainer')))



      @slow
      def   lowerCamelCase_       (						self)     ->      Union[str, Any]:





        '''simple docstring'''





        a__:					List[str]      							=     logging.StreamHandler(sys.stdout)
        logger.addHandler(lowercase)

        a__:					str      							=     self.get_auto_remove_tmp_dir()
        a__:					Optional[int]      							=     f'\n            {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py\n            --dataset_name huggingface/semantic-segmentation-test-sample\n            --output_dir {tmp_dir}\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n        '.split()

        run_command(self._launch_args + testargs)
        a__:					str      							=     get_results(lowercase)
        self.assertGreaterEqual(result['eval_overall_accuracy']   ,      0.10)



      @mock.patch.dict(os.environ   ,      {'WANDB_MODE': 'offline'})
      def   lowerCamelCase_       (						self)     ->      Optional[Any]:





        '''simple docstring'''





        a__:					int      							=     self.get_auto_remove_tmp_dir()
        a__:					List[str]      							=     f'\n            {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py\n            --model_name_or_path google/vit-base-patch16-224-in21k\n            --dataset_name hf-internal-testing/cats_vs_dogs_sample\n            --learning_rate 1e-4\n            --per_device_train_batch_size 2\n            --per_device_eval_batch_size 1\n            --max_train_steps 2\n            --train_val_split 0.1\n            --seed 42\n            --output_dir {tmp_dir}\n            --with_tracking\n            --checkpointing_steps 1\n        '.split()

        if is_cuda_and_apex_available():
          testargs.append('--fp16')

        run_command(self._launch_args + testargs)
        a__:					int      							=     get_results(lowercase)
        # The base model scores a 25%
        self.assertGreaterEqual(result['eval_accuracy']   ,      0.6)
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'step_1')))
        self.assertTrue(os.path.exists(os.path.join(lowercase   ,      'image_classification_no_trainer')))



"""simple docstring"""
from __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask


if is_tf_available():
 import tensorflow as tf

 from transformers import TFBlipTextModel
 from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST




class        __snake_case	:



      def __init__(						self   ,      lowercase   ,      lowercase=12   ,      lowercase=7   ,      lowercase=True   ,      lowercase=True   ,      lowercase=True   ,      lowercase=99   ,      lowercase=32   ,      lowercase=32   ,      lowercase=2   ,      lowercase=4   ,      lowercase=37   ,      lowercase=0.1   ,      lowercase=0.1   ,      lowercase=5_12   ,      lowercase=0.02   ,      lowercase=0   ,      lowercase=None   ,      )     ->      Optional[int]:





        '''simple docstring'''





        a__:					List[Any]      							=     parent
        a__:					Any      							=     batch_size
        a__:					int      							=     seq_length
        a__:					List[str]      							=     is_training
        a__:					Any      							=     use_input_mask
        a__:					Optional[Any]      							=     use_labels
        a__:					List[Any]      							=     vocab_size
        a__:					Optional[Any]      							=     hidden_size
        a__:					Any      							=     projection_dim
        a__:					List[str]      							=     num_hidden_layers
        a__:					Dict      							=     num_attention_heads
        a__:					int      							=     intermediate_size
        a__:					Tuple      							=     dropout
        a__:					Union[str, Any]      							=     attention_dropout
        a__:					str      							=     max_position_embeddings
        a__:					List[str]      							=     initializer_range
        a__:					Optional[int]      							=     scope
        a__:					List[Any]      							=     bos_token_id



      def   lowerCamelCase_       (						self)     ->      Dict:





        '''simple docstring'''





        a__:					str      							=     ids_tensor([self.batch_size, self.seq_length]   ,      self.vocab_size)

        a__:					str      							=     None
        if self.use_input_mask:
          a__:					List[str]      							=     random_attention_mask([self.batch_size, self.seq_length])

        if input_mask is not None:
          a__:					str      							=     input_mask.numpy()
          a__							,   a__:					Any      							=     input_mask.shape
          a__:					Tuple      							=     np.random.randint(1   ,      seq_length - 1   ,      size=(batch_size,))
          for batch_idx, start_index in enumerate(lowercase):
            a__:					Tuple      							=     1
            a__:					Any      							=     0

        a__:					Any      							=     self.get_config()

        return config, input_ids, tf.convert_to_tensor(lowercase)



      def   lowerCamelCase_       (						self)     ->      Union[str, Any]:





        '''simple docstring'''





        return BlipTextConfig(
            vocab_size=self.vocab_size   ,      hidden_size=self.hidden_size   ,      projection_dim=self.projection_dim   ,      num_hidden_layers=self.num_hidden_layers   ,      num_attention_heads=self.num_attention_heads   ,      intermediate_size=self.intermediate_size   ,      dropout=self.dropout   ,      attention_dropout=self.attention_dropout   ,      max_position_embeddings=self.max_position_embeddings   ,      initializer_range=self.initializer_range   ,      bos_token_id=self.bos_token_id   ,      )



      def   lowerCamelCase_       (						self   ,      lowercase   ,      lowercase   ,      lowercase)     ->      List[Any]:





        '''simple docstring'''





        a__:					Any      							=     TFBlipTextModel(config=lowercase)
        a__:					Union[str, Any]      							=     model(lowercase   ,      attention_mask=lowercase   ,      training=lowercase)
        a__:					List[Any]      							=     model(lowercase   ,      training=lowercase)
        self.parent.assertEqual(result.last_hidden_state.shape   ,      (self.batch_size, self.seq_length, self.hidden_size))
        self.parent.assertEqual(result.pooler_output.shape   ,      (self.batch_size, self.hidden_size))



      def   lowerCamelCase_       (						self)     ->      int:





        '''simple docstring'''





        a__:					Tuple      							=     self.prepare_config_and_inputs()
        a__							,   a__							,   a__:					Optional[Any]      							=     config_and_inputs
        a__:					Dict      							=     {'input_ids': input_ids, 'attention_mask': input_mask}
        return config, inputs_dict







@require_tf
class        __snake_case	(					__lowerCAmelCase	,				unittest.TestCase    ):
      a__				=		(TFBlipTextModel,) if is_tf_available() else ()
      a__				=		False
      a__				=		False
      a__				=		False



      def   lowerCamelCase_       (						self)     ->      Any:





        '''simple docstring'''





        a__:					List[Any]      							=     BlipTextModelTester(self)
        a__:					int      							=     ConfigTester(self   ,      config_class=lowercase   ,      hidden_size=37)



      def   lowerCamelCase_       (						self)     ->      Optional[Any]:





        '''simple docstring'''





        self.config_tester.run_common_tests()



      def   lowerCamelCase_       (						self)     ->      Union[str, Any]:





        '''simple docstring'''





        a__:					List[str]      							=     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowercase)



      def   lowerCamelCase_       (						self)     ->      Dict:





        '''simple docstring'''





        pass



      def   lowerCamelCase_       (						self)     ->      List[str]:





        '''simple docstring'''





        pass



      @unittest.skip(reason='Blip does not use inputs_embeds')
      def   lowerCamelCase_       (						self)     ->      List[str]:





        '''simple docstring'''





        pass



      @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING')
      def   lowerCamelCase_       (						self)     ->      Any:





        '''simple docstring'''





        pass



      @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING')
      def   lowerCamelCase_       (						self)     ->      Tuple:





        '''simple docstring'''





        pass



      @slow
      def   lowerCamelCase_       (						self)     ->      List[Any]:





        '''simple docstring'''





        for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          a__:					Tuple      							=     TFBlipTextModel.from_pretrained(lowercase)
          self.assertIsNotNone(lowercase)



      def   lowerCamelCase_       (						self   ,      lowercase=True)     ->      str:





        '''simple docstring'''





        super().test_pt_tf_model_equivalence(allow_missing_keys=lowercase)


