





"""simple docstring"""





import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
from ...utils import logging
from ..auto import CONFIG_MAPPING


SCREAMING_SNAKE_CASE__   =  logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__   =  {
    "salesforce/blip2-opt-2.7b": "https://huggingface.co/salesforce/blip2-opt-2.7b/resolve/main/config.json",
}

class 						lowercase   (   _UpperCAmelCase   ):
      _SCREAMING_SNAKE_CASE							      = 'blip_2_vision_model'





      def __init__(			self ,		lowercase=1_408 ,		lowercase=6_144 ,		lowercase=39 ,		lowercase=16 ,		lowercase=224 ,		lowercase=14 ,		lowercase="gelu" ,		lowercase=0.00_001 ,		lowercase=0.0 ,		lowercase=1e-10 ,		lowercase=True ,		**lowercase ,		)						->	Any:
            super().__init__(**lowercase					)

            lowerCAmelCase    		=			hidden_size
            lowerCAmelCase    		=			intermediate_size
            lowerCAmelCase    		=			num_hidden_layers
            lowerCAmelCase    		=			num_attention_heads
            lowerCAmelCase    		=			patch_size
            lowerCAmelCase    		=			image_size
            lowerCAmelCase    		=			initializer_range
            lowerCAmelCase    		=			attention_dropout
            lowerCAmelCase    		=			layer_norm_eps
            lowerCAmelCase    		=			hidden_act
            lowerCAmelCase    		=			qkv_bias





      @classmethod
      def        _snake_case     (			cls ,		lowercase ,		**lowercase					)						->	"PretrainedConfig":
            cls._set_token_in_kwargs(lowercase					)

            lowerCAmelCase		,						lowerCAmelCase    		=			cls.get_config_dict(lowercase ,		**lowercase					)

            # get the vision config dict if we are loading from Blip2Config
            if config_dict.get("""model_type"""					) == "blip-2":
                  lowerCAmelCase    		=			config_dict["""vision_config"""]

            if "model_type" in config_dict and hasattr(cls ,		"""model_type"""					) and config_dict["model_type"] != cls.model_type:
                  logger.warning(
                      f'You are using a model of type {config_dict["model_type"]} to instantiate a model of type '
                      f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'					)

            return cls.from_dict(lowercase ,		**lowercase					)







class 						lowercase   (   _UpperCAmelCase   ):
      _SCREAMING_SNAKE_CASE							      = 'blip_2_qformer'





      def __init__(			self ,		lowercase=30_522 ,		lowercase=768 ,		lowercase=12 ,		lowercase=12 ,		lowercase=3_072 ,		lowercase="gelu" ,		lowercase=0.1 ,		lowercase=0.1 ,		lowercase=512 ,		lowercase=0.02 ,		lowercase=1e-12 ,		lowercase=0 ,		lowercase="absolute" ,		lowercase=2 ,		lowercase=1_408 ,		**lowercase ,		)						->	Any:
            super().__init__(pad_token_id=lowercase ,		**lowercase					)

            lowerCAmelCase    		=			vocab_size
            lowerCAmelCase    		=			hidden_size
            lowerCAmelCase    		=			num_hidden_layers
            lowerCAmelCase    		=			num_attention_heads
            lowerCAmelCase    		=			hidden_act
            lowerCAmelCase    		=			intermediate_size
            lowerCAmelCase    		=			hidden_dropout_prob
            lowerCAmelCase    		=			attention_probs_dropout_prob
            lowerCAmelCase    		=			max_position_embeddings
            lowerCAmelCase    		=			initializer_range
            lowerCAmelCase    		=			layer_norm_eps
            lowerCAmelCase    		=			position_embedding_type
            lowerCAmelCase    		=			cross_attention_frequency
            lowerCAmelCase    		=			encoder_hidden_size





      @classmethod
      def        _snake_case     (			cls ,		lowercase ,		**lowercase					)						->	"PretrainedConfig":
            cls._set_token_in_kwargs(lowercase					)

            lowerCAmelCase		,						lowerCAmelCase    		=			cls.get_config_dict(lowercase ,		**lowercase					)

            # get the qformer config dict if we are loading from Blip2Config
            if config_dict.get("""model_type"""					) == "blip-2":
                  lowerCAmelCase    		=			config_dict["""qformer_config"""]

            if "model_type" in config_dict and hasattr(cls ,		"""model_type"""					) and config_dict["model_type"] != cls.model_type:
                  logger.warning(
                      f'You are using a model of type {config_dict["model_type"]} to instantiate a model of type '
                      f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'					)

            return cls.from_dict(lowercase ,		**lowercase					)







class 						lowercase   (   _UpperCAmelCase   ):
      _SCREAMING_SNAKE_CASE							      = 'blip-2'
      _SCREAMING_SNAKE_CASE							      = True





      def __init__(			self ,		lowercase=None ,		lowercase=None ,		lowercase=None ,		lowercase=32 ,		**lowercase					)						->	Union[str, Any]:
            super().__init__(**lowercase					)

            if vision_config is None:
                  lowerCAmelCase    		=			{}
                  logger.info("""vision_config is None. initializing the Blip2VisionConfig with default values."""					)

            if qformer_config is None:
                  lowerCAmelCase    		=			{}
                  logger.info("""qformer_config is None. Initializing the Blip2QFormerConfig with default values."""					)

            if text_config is None:
                  lowerCAmelCase    		=			{}
                  logger.info("""text_config is None. Initializing the text config with default values (`OPTConfig`)."""					)

            lowerCAmelCase    		=			BlipaVisionConfig(**lowercase					)
            lowerCAmelCase    		=			BlipaQFormerConfig(**lowercase					)
            lowerCAmelCase    		=			text_config["""model_type"""] if """model_type""" in text_config else """opt"""
            lowerCAmelCase    		=			CONFIG_MAPPING[text_model_type](**lowercase					)

            lowerCAmelCase    		=			self.text_config.tie_word_embeddings
            lowerCAmelCase    		=			self.text_config.is_encoder_decoder

            lowerCAmelCase    		=			num_query_tokens
            lowerCAmelCase    		=			self.vision_config.hidden_size
            lowerCAmelCase    		=			self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
            lowerCAmelCase    		=			1.0
            lowerCAmelCase    		=			0.02





      @classmethod
      def        _snake_case     (			cls ,		lowercase ,		lowercase ,		lowercase ,		**lowercase ,		)						->	int:
            return cls(
                vision_config=vision_config.to_dict() ,		qformer_config=qformer_config.to_dict() ,		text_config=text_config.to_dict() ,		**lowercase ,		)





      def        _snake_case     (			self					)						->	List[str]:
            lowerCAmelCase    		=			copy.deepcopy(self.__dict__					)
            lowerCAmelCase    		=			self.vision_config.to_dict()
            lowerCAmelCase    		=			self.qformer_config.to_dict()
            lowerCAmelCase    		=			self.text_config.to_dict()
            lowerCAmelCase    		=			self.__class__.model_type
            return output













"""simple docstring"""





import ast
import os
import re
import shutil
import tempfile
import unittest
from unittest import mock

import torch

from accelerate.test_utils.examples import compare_against_test
from accelerate.test_utils.testing import TempDirTestCase, require_trackers, run_command, slow
from accelerate.utils import write_basic_config


# DataLoaders built from `test_samples/MRPC` for quick testing
# Should mock `{script_name}.get_dataloaders` via:
# @mock.patch("{script_name}.get_dataloaders", mocked_dataloaders)

SCREAMING_SNAKE_CASE__   =  [
    "cross_validation.py",
    "gradient_accumulation.py",
    "local_sgd.py",
    "multi_process_metrics.py",
    "memory.py",
    "automatic_gradient_accumulation.py",
    "fsdp_with_peak_mem_tracking.py",
    "deepspeed_with_config_support.py",
    "megatron_lm_gpt_pretraining.py",
]

class 						lowercase   (   unittest.TestCase   ):





      def        _snake_case     (			self ,		lowercase ,		lowercase ,		lowercase = None ,		lowercase = None					)						->	Dict:
            lowerCAmelCase    		=			None
            lowerCAmelCase    		=			os.path.abspath(os.path.join("""examples""" ,		"""by_feature"""					)					)
            lowerCAmelCase    		=			os.path.abspath("""examples"""					)
            for item in os.listdir(lowercase					):
                  if item not in EXCLUDE_EXAMPLES:
                        lowerCAmelCase    		=			os.path.join(lowercase ,		lowercase					)
                        if os.path.isfile(lowercase					) and ".py" in item_path:
                              with self.subTest(
                                  tested_script=lowercase ,		feature_script=lowercase ,		tested_section="""main()""" if parser_only else """training_function()""" ,		):
                                    lowerCAmelCase    		=			compare_against_test(
                                        os.path.join(lowercase ,		lowercase					) ,		lowercase ,		lowercase ,		lowercase					)
                                    lowerCAmelCase    		=			"""\n""".join(lowercase					)
                                    if special_strings is not None:
                                          for string in special_strings:
                                                lowerCAmelCase    		=			diff.replace(lowercase ,		""""""					)
                                    self.assertEqual(lowercase ,		""""""					)





      def        _snake_case     (			self					)						->	List[Any]:
            self.one_complete_example("""complete_nlp_example.py""" ,		lowercase					)
            self.one_complete_example("""complete_nlp_example.py""" ,		lowercase					)





      def        _snake_case     (			self					)						->	Any:
            lowerCAmelCase    		=			os.path.abspath(os.path.join("""examples""" ,		"""cv_example.py"""					)					)
            lowerCAmelCase    		=			[
                """ """ * 16 + """{\n\n""",
                """ """ * 20 + """\"accuracy\": eval_metric[\"accuracy\"],\n\n""",
                """ """ * 20 + """\"f1\": eval_metric[\"f1\"],\n\n""",
                """ """ * 20 + """\"train_loss\": total_loss.item() / len(train_dataloader),\n\n""",
                """ """ * 20 + """\"epoch\": epoch,\n\n""",
                """ """ * 16 + """},\n\n""",
                """ """ * 16 + """step=epoch,\n""",
                """ """ * 12,
                """ """ * 8 + """for step, batch in enumerate(active_dataloader):\n""",
            ]
            self.one_complete_example("""complete_cv_example.py""" ,		lowercase ,		lowercase ,		lowercase					)
            self.one_complete_example("""complete_cv_example.py""" ,		lowercase ,		lowercase ,		lowercase					)







@mock.patch.dict(os.environ	,    {'TESTING_MOCKED_DATALOADERS': '1'}   )
class 						lowercase   (   _UpperCAmelCase   ):
      _SCREAMING_SNAKE_CASE							      = False





      @classmethod
      def        _snake_case     (			cls					)						->	Optional[int]:
            super().setUpClass()
            lowerCAmelCase    		=			tempfile.mkdtemp()
            lowerCAmelCase    		=			os.path.join(cls._tmpdir ,		"""default_config.yml"""					)

            write_basic_config(save_location=cls.configPath					)
            lowerCAmelCase    		=			["""accelerate""", """launch""", """--config_file""", cls.configPath]





      @classmethod
      def        _snake_case     (			cls					)						->	Optional[int]:
            super().tearDownClass()
            shutil.rmtree(cls._tmpdir					)





      def        _snake_case     (			self					)						->	str:
            lowerCAmelCase    		=			f'\n        examples/by_feature/checkpointing.py\n        --checkpointing_steps epoch\n        --output_dir {self.tmpdir}\n        '.split()
            run_command(self._launch_args + testargs					)
            self.assertTrue(os.path.exists(os.path.join(self.tmpdir ,		"""epoch_0"""					)					)					)





      def        _snake_case     (			self					)						->	Optional[int]:
            lowerCAmelCase    		=			f'\n        examples/by_feature/checkpointing.py\n        --checkpointing_steps 1\n        --output_dir {self.tmpdir}\n        '.split()
            lowerCAmelCase    		=			run_command(self._launch_args + testargs					)
            self.assertTrue(os.path.exists(os.path.join(self.tmpdir ,		"""step_2"""					)					)					)





      def        _snake_case     (			self					)						->	List[str]:
            lowerCAmelCase    		=			f'\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir ,		"epoch_0"					)}\n        '.split()
            lowerCAmelCase    		=			run_command(self._launch_args + testargs ,		return_stdout=lowercase					)
            self.assertNotIn("""epoch 0:""" ,		lowercase					)
            self.assertIn("""epoch 1:""" ,		lowercase					)





      def        _snake_case     (			self					)						->	Union[str, Any]:
            lowerCAmelCase    		=			f'\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir ,		"step_2"					)}\n        '.split()
            lowerCAmelCase    		=			run_command(self._launch_args + testargs ,		return_stdout=lowercase					)
            if torch.cuda.is_available():
                  lowerCAmelCase    		=			torch.cuda.device_count()
            else:
                  lowerCAmelCase    		=			1
            if num_processes > 1:
                  self.assertNotIn("""epoch 0:""" ,		lowercase					)
                  self.assertIn("""epoch 1:""" ,		lowercase					)
            else:
                  self.assertIn("""epoch 0:""" ,		lowercase					)
                  self.assertIn("""epoch 1:""" ,		lowercase					)





      @slow
      def        _snake_case     (			self					)						->	Tuple:
            lowerCAmelCase    		=			"""
        examples/by_feature/cross_validation.py
        --num_folds 2
        """.split()
            with mock.patch.dict(os.environ ,		{"""TESTING_MOCKED_DATALOADERS""": """0"""}					):
                  lowerCAmelCase    		=			run_command(self._launch_args + testargs ,		return_stdout=lowercase					)
                  lowerCAmelCase    		=			re.findall("""({.+})""" ,		lowercase					)
                  lowerCAmelCase    		=			[r for r in results if """accuracy""" in r][-1]
                  lowerCAmelCase    		=			ast.literal_eval(lowercase					)
                  self.assertGreaterEqual(results["""accuracy"""] ,		0.75					)





      def        _snake_case     (			self					)						->	int:
            lowerCAmelCase    		=			["""examples/by_feature/multi_process_metrics.py"""]
            run_command(self._launch_args + testargs					)





      @require_trackers
      @mock.patch.dict(os.environ ,		{"""WANDB_MODE""": """offline"""}					)
      def        _snake_case     (			self					)						->	Any:
            with tempfile.TemporaryDirectory() as tmpdir:
                  lowerCAmelCase    		=			f'\n            examples/by_feature/tracking.py\n            --with_tracking\n            --project_dir {tmpdir}\n            '.split()
                  run_command(self._launch_args + testargs					)
                  self.assertTrue(os.path.exists(os.path.join(lowercase ,		"""tracking"""					)					)					)





      def        _snake_case     (			self					)						->	Union[str, Any]:
            lowerCAmelCase    		=			["""examples/by_feature/gradient_accumulation.py"""]
            run_command(self._launch_args + testargs					)





      def        _snake_case     (			self					)						->	int:
            lowerCAmelCase    		=			["""examples/by_feature/local_sgd.py"""]
            run_command(self._launch_args + testargs					)






