



import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetInpaintPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
    TEXT_TO_IMAGE_IMAGE_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()






class 		lowercase						( a__ ,    a__ ,    a__ ,    unittest.TestCase):






	"""simple docstring"""


	a__      :					Optional[int]		   =							StableDiffusionControlNetInpaintPipeline
	a__      :					Optional[int]		   =							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
	a__      :					Dict		   =							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
	a__      :					int		   =							frozenset({"control_image"})  # skip `image` and `mask` for now, only test for control_image
	a__      :					Optional[Any]		   =							TEXT_TO_IMAGE_IMAGE_PARAMS




	def   _SCREAMING_SNAKE_CASE		(	self	:						Any     )			-> List[str]:
							torch.manual_seed(0     )
							UpperCAmelCase_=   UNetaDConditionModel(
							    block_out_channels=(32, 64)						,  layers_per_block=2						,  sample_size=32						,  in_channels=9						,  out_channels=4						,  down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")						,  up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")						,  cross_attention_dim=32						,  )
							torch.manual_seed(0     )
							UpperCAmelCase_=   ControlNetModel(
							    block_out_channels=(32, 64)						,  layers_per_block=2						,  in_channels=4						,  down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")						,  cross_attention_dim=32						,  conditioning_embedding_out_channels=(16, 32)						,  )
							torch.manual_seed(0     )
							UpperCAmelCase_=   DDIMScheduler(
							    beta_start=0.00_085						,  beta_end=0.012						,  beta_schedule="""scaled_linear"""						,  clip_sample=_snake_case						,  set_alpha_to_one=_snake_case						,  )
							torch.manual_seed(0     )
							UpperCAmelCase_=   AutoencoderKL(
							    block_out_channels=[32, 64]						,  in_channels=3						,  out_channels=3						,  down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]						,  up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]						,  latent_channels=4						,  )
							torch.manual_seed(0     )
							UpperCAmelCase_=   CLIPTextConfig(
							    bos_token_id=0						,  eos_token_id=2						,  hidden_size=32						,  intermediate_size=37						,  layer_norm_eps=1E-05						,  num_attention_heads=4						,  num_hidden_layers=5						,  pad_token_id=1						,  vocab_size=1_000						,  )
							UpperCAmelCase_=   CLIPTextModel(_snake_case     )
							UpperCAmelCase_=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""     )

							UpperCAmelCase_=   {
							    """unet""": unet,
							    """controlnet""": controlnet,
							    """scheduler""": scheduler,
							    """vae""": vae,
							    """text_encoder""": text_encoder,
							    """tokenizer""": tokenizer,
							    """safety_checker""": None,
							    """feature_extractor""": None,
							}
							return components




	def   _SCREAMING_SNAKE_CASE		(	self	:						int						,  __UpperCAmelCase	:						Optional[Any]						,  __UpperCAmelCase	:						Dict=0     )			-> List[str]:






							if str(_snake_case     ).startswith("""mps"""     ):
													UpperCAmelCase_=   torch.manual_seed(_snake_case     )
							else:
													UpperCAmelCase_=   torch.Generator(device=_snake_case     ).manual_seed(_snake_case     )

							UpperCAmelCase_=   2
							UpperCAmelCase_=   randn_tensor(
							    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)						,  generator=_snake_case						,  device=torch.device(_snake_case     )						,  )
							UpperCAmelCase_=   floats_tensor((1, 3, 32, 32)						,  rng=random.Random(_snake_case     )     ).to(_snake_case     )
							UpperCAmelCase_=   init_image.cpu().permute(0						,  2						,  3						,  1     )[0]

							UpperCAmelCase_=   Image.fromarray(np.uinta(_snake_case     )     ).convert("""RGB"""     ).resize((64, 64)     )
							UpperCAmelCase_=   Image.fromarray(np.uinta(init_image + 4     )     ).convert("""RGB"""     ).resize((64, 64)     )

							UpperCAmelCase_=   {
							    """prompt""": """A painting of a squirrel eating a burger""",
							    """generator""": generator,
							    """num_inference_steps""": 2,
							    """guidance_scale""": 6.0,
							    """output_type""": """numpy""",
							    """image""": image,
							    """mask_image""": mask_image,
							    """control_image""": control_image,
							}

							return inputs




	def   _SCREAMING_SNAKE_CASE		(	self	:						Dict     )			-> str:
							return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3     )




	@unittest.skipIf(
	    torch_device != """cuda""" or not is_xformers_available()						,  reason="""XFormers attention is only available with CUDA and `xformers` installed"""						,  )
	def   _SCREAMING_SNAKE_CASE		(	self	:						Dict     )			-> Dict:
							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3     )




	def   _SCREAMING_SNAKE_CASE		(	self	:						int     )			-> Tuple:
							self._test_inference_batch_single_identical(expected_max_diff=2E-3     )






class 		lowercase						( a__):






	"""simple docstring"""


	a__      :					Any		   =							StableDiffusionControlNetInpaintPipeline
	a__      :					Any		   =							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
	a__      :					Optional[Any]		   =							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
	a__      :					int		   =							frozenset([])




	def   _SCREAMING_SNAKE_CASE		(	self	:						int     )			-> Dict:
							torch.manual_seed(0     )
							UpperCAmelCase_=   UNetaDConditionModel(
							    block_out_channels=(32, 64)						,  layers_per_block=2						,  sample_size=32						,  in_channels=4						,  out_channels=4						,  down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")						,  up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")						,  cross_attention_dim=32						,  )
							torch.manual_seed(0     )
							UpperCAmelCase_=   ControlNetModel(
							    block_out_channels=(32, 64)						,  layers_per_block=2						,  in_channels=4						,  down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")						,  cross_attention_dim=32						,  conditioning_embedding_out_channels=(16, 32)						,  )
							torch.manual_seed(0     )
							UpperCAmelCase_=   DDIMScheduler(
							    beta_start=0.00_085						,  beta_end=0.012						,  beta_schedule="""scaled_linear"""						,  clip_sample=_snake_case						,  set_alpha_to_one=_snake_case						,  )
							torch.manual_seed(0     )
							UpperCAmelCase_=   AutoencoderKL(
							    block_out_channels=[32, 64]						,  in_channels=3						,  out_channels=3						,  down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]						,  up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]						,  latent_channels=4						,  )
							torch.manual_seed(0     )
							UpperCAmelCase_=   CLIPTextConfig(
							    bos_token_id=0						,  eos_token_id=2						,  hidden_size=32						,  intermediate_size=37						,  layer_norm_eps=1E-05						,  num_attention_heads=4						,  num_hidden_layers=5						,  pad_token_id=1						,  vocab_size=1_000						,  )
							UpperCAmelCase_=   CLIPTextModel(_snake_case     )
							UpperCAmelCase_=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""     )

							UpperCAmelCase_=   {
							    """unet""": unet,
							    """controlnet""": controlnet,
							    """scheduler""": scheduler,
							    """vae""": vae,
							    """text_encoder""": text_encoder,
							    """tokenizer""": tokenizer,
							    """safety_checker""": None,
							    """feature_extractor""": None,
							}
							return components






class 		lowercase						( a__ ,    a__ ,    unittest.TestCase):






	"""simple docstring"""


	a__      :					List[str]		   =							StableDiffusionControlNetInpaintPipeline
	a__      :					str		   =							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
	a__      :					int		   =							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS




	def   _SCREAMING_SNAKE_CASE		(	self	:						Dict     )			-> str:
							torch.manual_seed(0     )
							UpperCAmelCase_=   UNetaDConditionModel(
							    block_out_channels=(32, 64)						,  layers_per_block=2						,  sample_size=32						,  in_channels=9						,  out_channels=4						,  down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")						,  up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")						,  cross_attention_dim=32						,  )
							torch.manual_seed(0     )

							def init_weights(__UpperCAmelCase	:						Optional[Any]     ):
													if isinstance(_snake_case						,  torch.nn.Convad     ):
																			torch.nn.init.normal(m.weight     )
																			m.bias.data.fill_(1.0     )

							UpperCAmelCase_=   ControlNetModel(
							    block_out_channels=(32, 64)						,  layers_per_block=2						,  in_channels=4						,  down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")						,  cross_attention_dim=32						,  conditioning_embedding_out_channels=(16, 32)						,  )
							controlneta.controlnet_down_blocks.apply(_snake_case     )

							torch.manual_seed(0     )
							UpperCAmelCase_=   ControlNetModel(
							    block_out_channels=(32, 64)						,  layers_per_block=2						,  in_channels=4						,  down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")						,  cross_attention_dim=32						,  conditioning_embedding_out_channels=(16, 32)						,  )
							controlneta.controlnet_down_blocks.apply(_snake_case     )

							torch.manual_seed(0     )
							UpperCAmelCase_=   DDIMScheduler(
							    beta_start=0.00_085						,  beta_end=0.012						,  beta_schedule="""scaled_linear"""						,  clip_sample=_snake_case						,  set_alpha_to_one=_snake_case						,  )
							torch.manual_seed(0     )
							UpperCAmelCase_=   AutoencoderKL(
							    block_out_channels=[32, 64]						,  in_channels=3						,  out_channels=3						,  down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]						,  up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]						,  latent_channels=4						,  )
							torch.manual_seed(0     )
							UpperCAmelCase_=   CLIPTextConfig(
							    bos_token_id=0						,  eos_token_id=2						,  hidden_size=32						,  intermediate_size=37						,  layer_norm_eps=1E-05						,  num_attention_heads=4						,  num_hidden_layers=5						,  pad_token_id=1						,  vocab_size=1_000						,  )
							UpperCAmelCase_=   CLIPTextModel(_snake_case     )
							UpperCAmelCase_=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""     )

							UpperCAmelCase_=   MultiControlNetModel([controlneta, controlneta]     )

							UpperCAmelCase_=   {
							    """unet""": unet,
							    """controlnet""": controlnet,
							    """scheduler""": scheduler,
							    """vae""": vae,
							    """text_encoder""": text_encoder,
							    """tokenizer""": tokenizer,
							    """safety_checker""": None,
							    """feature_extractor""": None,
							}
							return components




	def   _SCREAMING_SNAKE_CASE		(	self	:						Tuple						,  __UpperCAmelCase	:						Dict						,  __UpperCAmelCase	:						Tuple=0     )			-> Dict:






							if str(_snake_case     ).startswith("""mps"""     ):
													UpperCAmelCase_=   torch.manual_seed(_snake_case     )
							else:
													UpperCAmelCase_=   torch.Generator(device=_snake_case     ).manual_seed(_snake_case     )

							UpperCAmelCase_=   2

							UpperCAmelCase_=   [
							    randn_tensor(
							        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)						,  generator=_snake_case						,  device=torch.device(_snake_case     )						,  ),
							    randn_tensor(
							        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)						,  generator=_snake_case						,  device=torch.device(_snake_case     )						,  ),
							]
							UpperCAmelCase_=   floats_tensor((1, 3, 32, 32)						,  rng=random.Random(_snake_case     )     ).to(_snake_case     )
							UpperCAmelCase_=   init_image.cpu().permute(0						,  2						,  3						,  1     )[0]

							UpperCAmelCase_=   Image.fromarray(np.uinta(_snake_case     )     ).convert("""RGB"""     ).resize((64, 64)     )
							UpperCAmelCase_=   Image.fromarray(np.uinta(init_image + 4     )     ).convert("""RGB"""     ).resize((64, 64)     )

							UpperCAmelCase_=   {
							    """prompt""": """A painting of a squirrel eating a burger""",
							    """generator""": generator,
							    """num_inference_steps""": 2,
							    """guidance_scale""": 6.0,
							    """output_type""": """numpy""",
							    """image""": image,
							    """mask_image""": mask_image,
							    """control_image""": control_image,
							}

							return inputs




	def   _SCREAMING_SNAKE_CASE		(	self	:						Optional[Any]     )			-> List[Any]:
							UpperCAmelCase_=   self.get_dummy_components()
							UpperCAmelCase_=   self.pipeline_class(**_snake_case     )
							pipe.to(_snake_case     )

							UpperCAmelCase_=   10.0
							UpperCAmelCase_=   4

							UpperCAmelCase_=   self.get_dummy_inputs(_snake_case     )
							UpperCAmelCase_=   steps
							UpperCAmelCase_=   scale
							UpperCAmelCase_=   pipe(**_snake_case     )[0]

							UpperCAmelCase_=   self.get_dummy_inputs(_snake_case     )
							UpperCAmelCase_=   steps
							UpperCAmelCase_=   scale
							UpperCAmelCase_=   pipe(**_snake_case						,  control_guidance_start=0.1						,  control_guidance_end=0.2     )[0]

							UpperCAmelCase_=   self.get_dummy_inputs(_snake_case     )
							UpperCAmelCase_=   steps
							UpperCAmelCase_=   scale
							UpperCAmelCase_=   pipe(**_snake_case						,  control_guidance_start=[0.1, 0.3]						,  control_guidance_end=[0.2, 0.7]     )[0]

							UpperCAmelCase_=   self.get_dummy_inputs(_snake_case     )
							UpperCAmelCase_=   steps
							UpperCAmelCase_=   scale
							UpperCAmelCase_=   pipe(**_snake_case						,  control_guidance_start=0.4						,  control_guidance_end=[0.5, 0.8]     )[0]

							# make sure that all outputs are different
							assert np.sum(np.abs(output_a - output_a     )     ) > 1E-3
							assert np.sum(np.abs(output_a - output_a     )     ) > 1E-3
							assert np.sum(np.abs(output_a - output_a     )     ) > 1E-3




	def   _SCREAMING_SNAKE_CASE		(	self	:						Union[str, Any]     )			-> int:
							return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3     )




	@unittest.skipIf(
	    torch_device != """cuda""" or not is_xformers_available()						,  reason="""XFormers attention is only available with CUDA and `xformers` installed"""						,  )
	def   _SCREAMING_SNAKE_CASE		(	self	:						str     )			-> List[Any]:
							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3     )




	def   _SCREAMING_SNAKE_CASE		(	self	:						Dict     )			-> Dict:
							self._test_inference_batch_single_identical(expected_max_diff=2E-3     )




	def   _SCREAMING_SNAKE_CASE		(	self	:						Any     )			-> Dict:
							UpperCAmelCase_=   self.get_dummy_components()
							UpperCAmelCase_=   self.pipeline_class(**_snake_case     )
							pipe.to(_snake_case     )
							pipe.set_progress_bar_config(disable=_snake_case     )
							with tempfile.TemporaryDirectory() as tmpdir:
													try:
																			# save_pretrained is not implemented for Multi-ControlNet
																			pipe.save_pretrained(_snake_case     )
													except NotImplementedError:
																			pass






@slow
@require_torch_gpu
class 		lowercase						( unittest.TestCase):






	"""simple docstring"""


	def   _SCREAMING_SNAKE_CASE		(	self	:						Optional[Any]     )			-> Optional[Any]:
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()




	def   _SCREAMING_SNAKE_CASE		(	self	:						int     )			-> str:
							UpperCAmelCase_=   ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""     )

							UpperCAmelCase_=   StableDiffusionControlNetInpaintPipeline.from_pretrained(
							    """runwayml/stable-diffusion-inpainting"""						,  safety_checker=_snake_case						,  controlnet=_snake_case     )
							pipe.enable_model_cpu_offload()
							pipe.set_progress_bar_config(disable=_snake_case     )

							UpperCAmelCase_=   torch.Generator(device="""cpu"""     ).manual_seed(0     )
							UpperCAmelCase_=   load_image(
							    """https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"""     ).resize((512, 512)     )

							UpperCAmelCase_=   load_image(
							    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
							    """/stable_diffusion_inpaint/input_bench_mask.png"""     ).resize((512, 512)     )

							UpperCAmelCase_=   """pitch black hole"""

							UpperCAmelCase_=   load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"""     ).resize((512, 512)     )

							UpperCAmelCase_=   pipe(
							    _snake_case						,  image=_snake_case						,  mask_image=_snake_case						,  control_image=_snake_case						,  generator=_snake_case						,  output_type="""np"""						,  num_inference_steps=3						,  )

							UpperCAmelCase_=   output.images[0]

							assert image.shape == (512, 512, 3)

							UpperCAmelCase_=   load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy"""     )

							assert np.abs(expected_image - image     ).max() < 9E-2




	def   _SCREAMING_SNAKE_CASE		(	self	:						int     )			-> List[Any]:
							UpperCAmelCase_=   ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint"""     )

							UpperCAmelCase_=   StableDiffusionControlNetInpaintPipeline.from_pretrained(
							    """runwayml/stable-diffusion-v1-5"""						,  safety_checker=_snake_case						,  controlnet=_snake_case     )
							UpperCAmelCase_=   DDIMScheduler.from_config(pipe.scheduler.config     )
							pipe.enable_model_cpu_offload()
							pipe.set_progress_bar_config(disable=_snake_case     )

							UpperCAmelCase_=   torch.Generator(device="""cpu"""     ).manual_seed(33     )

							UpperCAmelCase_=   load_image(
							    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"""     )
							UpperCAmelCase_=   init_image.resize((512, 512)     )

							UpperCAmelCase_=   load_image(
							    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"""     )
							UpperCAmelCase_=   mask_image.resize((512, 512)     )

							UpperCAmelCase_=   """a handsome man with ray-ban sunglasses"""

							def make_inpaint_condition(__UpperCAmelCase	:						Tuple						,  __UpperCAmelCase	:						Optional[int]     ):
													UpperCAmelCase_=   np.array(image.convert("""RGB"""     )     ).astype(np.floataa     ) / 255.0
													UpperCAmelCase_=   np.array(image_mask.convert("""L"""     )     ).astype(np.floataa     ) / 255.0

													assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
													UpperCAmelCase_=   -1.0  # set as masked pixel
													UpperCAmelCase_=   np.expand_dims(_snake_case						,  0     ).transpose(0						,  3						,  1						,  2     )
													UpperCAmelCase_=   torch.from_numpy(_snake_case     )
													return image

							UpperCAmelCase_=   make_inpaint_condition(_snake_case						,  _snake_case     )

							UpperCAmelCase_=   pipe(
							    _snake_case						,  image=_snake_case						,  mask_image=_snake_case						,  control_image=_snake_case						,  guidance_scale=9.0						,  eta=1.0						,  generator=_snake_case						,  num_inference_steps=20						,  output_type="""np"""						,  )
							UpperCAmelCase_=   output.images[0]

							assert image.shape == (512, 512, 3)

							UpperCAmelCase_=   load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy"""     )

							assert np.abs(expected_image - image     ).max() < 9E-2











"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import is_detectrona_available, logging


__UpperCamelCase			:		List[Any]		    =   logging.get_logger(__name__)

__UpperCamelCase			:		Union[str, Any]		    =   {
    '''layoutlmv2-base-uncased''': '''https://huggingface.co/microsoft/layoutlmv2-base-uncased/resolve/main/config.json''',
    '''layoutlmv2-large-uncased''': '''https://huggingface.co/microsoft/layoutlmv2-large-uncased/resolve/main/config.json''',
    # See all LayoutLMv2 models at https://huggingface.co/models?filter=layoutlmv2
}

# soft dependency
if is_detectrona_available():
       import detectrona







class 	a				(					a__   ):
 snake_case__    	=    '''layoutlmv2'''



 def __init__(			self							,    _snake_case=3_05_22							,    _snake_case=7_68							,    _snake_case=12							,    _snake_case=12							,    _snake_case=30_72							,    _snake_case="gelu"							,    _snake_case=0.1							,    _snake_case=0.1							,    _snake_case=5_12							,    _snake_case=2							,    _snake_case=0.02							,    _snake_case=1E-12							,    _snake_case=0							,    _snake_case=10_24							,    _snake_case=1_28							,    _snake_case=32							,    _snake_case=True							,    _snake_case=2_56							,    _snake_case=64							,    _snake_case=True							,    _snake_case=[7, 7, 2_56]							,    _snake_case=1_28							,    _snake_case=1_28							,    _snake_case=True							,    _snake_case=True							,    _snake_case=False							,    _snake_case=None							,    **_snake_case							,    ):







  """simple docstring"""






  super().__init__(
      vocab_size=_snake_case							,    hidden_size=_snake_case							,    num_hidden_layers=_snake_case							,    num_attention_heads=_snake_case							,    intermediate_size=_snake_case							,    hidden_act=_snake_case							,    hidden_dropout_prob=_snake_case							,    attention_probs_dropout_prob=_snake_case							,    max_position_embeddings=_snake_case							,    type_vocab_size=_snake_case							,    initializer_range=_snake_case							,    layer_norm_eps=_snake_case							,    pad_token_id=_snake_case							,    **_snake_case							,    )
  lowerCAmelCase  							=      max_ad_position_embeddings
  lowerCAmelCase  							=      max_rel_pos
  lowerCAmelCase  							=      rel_pos_bins
  lowerCAmelCase  							=      fast_qkv
  lowerCAmelCase  							=      max_rel_ad_pos
  lowerCAmelCase  							=      rel_ad_pos_bins
  lowerCAmelCase  							=      convert_sync_batchnorm
  lowerCAmelCase  							=      image_feature_pool_shape
  lowerCAmelCase  							=      coordinate_size
  lowerCAmelCase  							=      shape_size
  lowerCAmelCase  							=      has_relative_attention_bias
  lowerCAmelCase  							=      has_spatial_attention_bias
  lowerCAmelCase  							=      has_visual_segment_embedding
  lowerCAmelCase  							=      (
      detectrona_config_args if detectrona_config_args is not None else self.get_default_detectrona_config()
  )



 @classmethod
 def 					UpperCamelCase__   (			self			):







  """simple docstring"""






  return {
      "MODEL.MASK_ON": True,
      "MODEL.PIXEL_STD": [57.375, 57.120, 58.395],
      "MODEL.BACKBONE.NAME": "build_resnet_fpn_backbone",
      "MODEL.FPN.IN_FEATURES": ["res2", "res3", "res4", "res5"],
      "MODEL.ANCHOR_GENERATOR.SIZES": [[32], [64], [1_28], [2_56], [5_12]],
      "MODEL.RPN.IN_FEATURES": ["p2", "p3", "p4", "p5", "p6"],
      "MODEL.RPN.PRE_NMS_TOPK_TRAIN": 20_00,
      "MODEL.RPN.PRE_NMS_TOPK_TEST": 10_00,
      "MODEL.RPN.POST_NMS_TOPK_TRAIN": 10_00,
      "MODEL.POST_NMS_TOPK_TEST": 10_00,
      "MODEL.ROI_HEADS.NAME": "StandardROIHeads",
      "MODEL.ROI_HEADS.NUM_CLASSES": 5,
      "MODEL.ROI_HEADS.IN_FEATURES": ["p2", "p3", "p4", "p5"],
      "MODEL.ROI_BOX_HEAD.NAME": "FastRCNNConvFCHead",
      "MODEL.ROI_BOX_HEAD.NUM_FC": 2,
      "MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION": 14,
      "MODEL.ROI_MASK_HEAD.NAME": "MaskRCNNConvUpsampleHead",
      "MODEL.ROI_MASK_HEAD.NUM_CONV": 4,
      "MODEL.ROI_MASK_HEAD.POOLER_RESOLUTION": 7,
      "MODEL.RESNETS.DEPTH": 1_01,
      "MODEL.RESNETS.SIZES": [[32], [64], [1_28], [2_56], [5_12]],
      "MODEL.RESNETS.ASPECT_RATIOS": [[0.5, 1.0, 2.0]],
      "MODEL.RESNETS.OUT_FEATURES": ["res2", "res3", "res4", "res5"],
      "MODEL.RESNETS.NUM_GROUPS": 32,
      "MODEL.RESNETS.WIDTH_PER_GROUP": 8,
      "MODEL.RESNETS.STRIDE_IN_1X1": False,
  }



 def 					UpperCamelCase__   (			self			):







  """simple docstring"""






  lowerCAmelCase  							=      detectrona.config.get_cfg()
  for k, v in self.detectrona_config_args.items():
   lowerCAmelCase  							=      k.split('.'			)
   lowerCAmelCase  							=      detectrona_config
   for attribute in attributes[:-1]:
    lowerCAmelCase  							=      getattr(_snake_case							,    _snake_case			)
   setattr(_snake_case							,    attributes[-1]							,    _snake_case			)

  return detectrona_config





