




# This model implementation is heavily based on:

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 		__UpperCAmelCase(		lowercase__       ,	lowercase__       ,	lowercase__       ,	unittest.TestCase ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    StableDiffusionControlNetInpaintPipeline
     __UpperCAmelCase	: int						=    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
     __UpperCAmelCase	: Tuple						=    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
     __UpperCAmelCase	: str						=    frozenset({"""control_image"""} )  # skip `image` and `mask` for now, only test for control_image
     __UpperCAmelCase	: List[str]						=    TEXT_TO_IMAGE_IMAGE_PARAMS

     def 				__SCREAMING_SNAKE_CASE		(      self :       List[Any]    )			->			Any:






         """simple docstring"""
         torch.manual_seed(0    )
         a__      =       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    )
         a__      =       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    )
         a__      =       DDIMScheduler(
             beta_start=0.0_0_0_8_5						,				beta_end=0.0_1_2						,				beta_schedule="""scaled_linear"""						,				clip_sample=A						,				set_alpha_to_one=A						,				)
         torch.manual_seed(0    )
         a__      =       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    )
         a__      =       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=10_00						,				)
         a__      =       CLIPTextModel(A    )
         a__      =       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )

         a__      =       {
             """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 :       Optional[Any]						,				A :       Optional[int]						,				A :       str=0    )			->			Dict:






         """simple docstring"""
         if str(A    ).startswith("""mps"""    ):
             a__      =       torch.manual_seed(A    )
         else:
             a__      =       torch.Generator(device=A    ).manual_seed(A    )

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

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

         a__      =       {
             """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]    )			->			int:






         """simple docstring"""
         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    )			->			Optional[Any]:






         """simple docstring"""
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3    )






     def 				__SCREAMING_SNAKE_CASE		(      self :       Any    )			->			Optional[int]:






         """simple docstring"""
         self._test_inference_batch_single_identical(expected_max_diff=2E-3    )







class 		__UpperCAmelCase(		lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: Dict						=    StableDiffusionControlNetInpaintPipeline
     __UpperCAmelCase	: List[Any]						=    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
     __UpperCAmelCase	: List[str]						=    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
     __UpperCAmelCase	: List[str]						=    frozenset([] )

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






         """simple docstring"""
         torch.manual_seed(0    )
         a__      =       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    )
         a__      =       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    )
         a__      =       DDIMScheduler(
             beta_start=0.0_0_0_8_5						,				beta_end=0.0_1_2						,				beta_schedule="""scaled_linear"""						,				clip_sample=A						,				set_alpha_to_one=A						,				)
         torch.manual_seed(0    )
         a__      =       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    )
         a__      =       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=10_00						,				)
         a__      =       CLIPTextModel(A    )
         a__      =       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )

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







class 		__UpperCAmelCase(		lowercase__       ,	lowercase__       ,	unittest.TestCase ):





     """simple docstring"""



     __UpperCAmelCase	: Union[str, Any]						=    StableDiffusionControlNetInpaintPipeline
     __UpperCAmelCase	: List[Any]						=    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
     __UpperCAmelCase	: List[str]						=    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS

     def 				__SCREAMING_SNAKE_CASE		(      self :       Tuple    )			->			List[str]:






         """simple docstring"""
         torch.manual_seed(0    )
         a__      =       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(A :       Optional[Any]    ):
             if isinstance(A						,				torch.nn.Convad    ):
                 torch.nn.init.normal(m.weight    )
                 m.bias.data.fill_(1.0    )

         a__      =       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(A    )

         torch.manual_seed(0    )
         a__      =       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(A    )

         torch.manual_seed(0    )
         a__      =       DDIMScheduler(
             beta_start=0.0_0_0_8_5						,				beta_end=0.0_1_2						,				beta_schedule="""scaled_linear"""						,				clip_sample=A						,				set_alpha_to_one=A						,				)
         torch.manual_seed(0    )
         a__      =       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    )
         a__      =       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=10_00						,				)
         a__      =       CLIPTextModel(A    )
         a__      =       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )

         a__      =       MultiControlNetModel([controlneta, controlneta]    )

         a__      =       {
             """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 :       List[str]						,				A :       str						,				A :       Union[str, Any]=0    )			->			Dict:






         """simple docstring"""
         if str(A    ).startswith("""mps"""    ):
             a__      =       torch.manual_seed(A    )
         else:
             a__      =       torch.Generator(device=A    ).manual_seed(A    )

         a__      =       2

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

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

         a__      =       {
             """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]    )			->			Dict:






         """simple docstring"""
         a__      =       self.get_dummy_components()
         a__      =       self.pipeline_class(**A    )
         pipe.to(A    )

         a__      =       1_0.0
         a__      =       4

         a__      =       self.get_dummy_inputs(A    )
         a__      =       steps
         a__      =       scale
         a__      =       pipe(**A    )[0]

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

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

         a__      =       self.get_dummy_inputs(A    )
         a__      =       steps
         a__      =       scale
         a__      =       pipe(**A						,				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 :       Tuple    )			->			List[Any]:






         """simple docstring"""
         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 :       Optional[Any]    )			->			Tuple:






         """simple docstring"""
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3    )

     def 				__SCREAMING_SNAKE_CASE		(      self :       str    )			->			Dict:






         """simple docstring"""
         self._test_inference_batch_single_identical(expected_max_diff=2E-3    )






     def 				__SCREAMING_SNAKE_CASE		(      self :       Optional[int]    )			->			Union[str, Any]:






         """simple docstring"""
         a__      =       self.get_dummy_components()
         a__      =       self.pipeline_class(**A    )
         pipe.to(A    )
         pipe.set_progress_bar_config(disable=A    )
         with tempfile.TemporaryDirectory() as tmpdir:
             try:
                 # save_pretrained is not implemented for Multi-ControlNet
                 pipe.save_pretrained(A    )
             except NotImplementedError:
                 pass







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





     """simple docstring"""



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






         """simple docstring"""
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()

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






         """simple docstring"""
         a__      =       ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""    )

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

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

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

         a__      =       """pitch black hole"""

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

         a__      =       pipe(
             A						,				image=A						,				mask_image=A						,				control_image=A						,				generator=A						,				output_type="""np"""						,				num_inference_steps=3						,				)

         a__      =       output.images[0]

         assert image.shape == (5_12, 5_12, 3)

         a__      =       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    )			->			Union[str, Any]:






         """simple docstring"""
         a__      =       ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint"""    )

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

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

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

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

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

         def make_inpaint_condition(A :       Optional[int]						,				A :       List[str]    ):
             a__      =       np.array(image.convert("""RGB"""    )    ).astype(np.floataa    ) / 2_5_5.0
             a__      =       np.array(image_mask.convert("""L"""    )    ).astype(np.floataa    ) / 2_5_5.0

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

         a__      =       make_inpaint_condition(A						,				A    )

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

         assert image.shape == (5_12, 5_12, 3)

         a__      =       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












import warnings
from dataclasses import dataclass, field
from typing import Optional, Tuple

from .training_args import TrainingArguments
from .utils import cached_property, is_tf_available, logging, requires_backends


SCREAMING_SNAKE_CASE_						:					Optional[Any]			   =       logging.get_logger(__name__)

if is_tf_available():
 import tensorflow as tf







@dataclass
class 		__UpperCAmelCase(		lowercase__ ):





     """simple docstring"""



     __UpperCAmelCase	: int						=    """tf"""
     __UpperCAmelCase	: Optional[str]						=    field(
         default=lowercase__       ,	metadata={"""help""": """Name of TPU"""}       ,	)

     __UpperCAmelCase	: Optional[str]						=    field(
         default=lowercase__       ,	metadata={"""help""": """Zone of TPU"""}       ,	)

     __UpperCAmelCase	: Optional[str]						=    field(
         default=lowercase__       ,	metadata={"""help""": """Name of Cloud TPU-enabled project"""}       ,	)

     __UpperCAmelCase	: float						=    field(
         default=1.0       ,	metadata={"""help""": """Power for the Polynomial decay LR scheduler."""}       ,	)

     __UpperCAmelCase	: bool						=    field(default=lowercase__       ,	metadata={"""help""": """Whether to activate the XLA compilation or not"""} )

     @cached_property
     def 				__SCREAMING_SNAKE_CASE		(      self :       Dict    )			->			Tuple["tf.distribute.Strategy", int]:






         """simple docstring"""
         requires_backends(self						,				["""tf"""]    )
         logger.info("""Tensorflow: setting up strategy"""    )

         a__      =       tf.config.list_physical_devices("""GPU"""    )

         # Set to float16 at first
         if self.fpaa:
             tf.keras.mixed_precision.set_global_policy("""mixed_float16"""    )

         if self.no_cuda:
             a__      =       tf.distribute.OneDeviceStrategy(device="""/cpu:0"""    )
         else:
             try:
                 if self.tpu_name:
                     a__      =       tf.distribute.cluster_resolver.TPUClusterResolver(
                         self.tpu_name						,				zone=self.tpu_zone						,				project=self.gcp_project    )
                 else:
                     a__      =       tf.distribute.cluster_resolver.TPUClusterResolver()
             except ValueError:
                 if self.tpu_name:
                     raise RuntimeError(f"""Couldn't connect to TPU {self.tpu_name}!"""    )
                 else:
                     a__      =       None

             if tpu:
                 # Set to bfloat16 in case of TPU
                 if self.fpaa:
                     tf.keras.mixed_precision.set_global_policy("""mixed_bfloat16"""    )

                 tf.config.experimental_connect_to_cluster(A    )
                 tf.tpu.experimental.initialize_tpu_system(A    )

                 a__      =       tf.distribute.TPUStrategy(A    )

             elif len(A    ) == 0:
                 a__      =       tf.distribute.OneDeviceStrategy(device="""/cpu:0"""    )
             elif len(A    ) == 1:
                 a__      =       tf.distribute.OneDeviceStrategy(device="""/gpu:0"""    )
             elif len(A    ) > 1:
                 # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
                 a__      =       tf.distribute.MirroredStrategy()
             else:
                 raise ValueError("""Cannot find the proper strategy, please check your environment properties."""    )

         return strategy

     @property
     def 				__SCREAMING_SNAKE_CASE		(      self :       Tuple    )			->			"tf.distribute.Strategy":






         """simple docstring"""
         requires_backends(self						,				["""tf"""]    )
         return self._setup_strategy

     @property
     def 				__SCREAMING_SNAKE_CASE		(      self :       Dict    )			->			int:






         """simple docstring"""
         requires_backends(self						,				["""tf"""]    )
         return self._setup_strategy.num_replicas_in_sync

     @property
     def 				__SCREAMING_SNAKE_CASE		(      self :       Dict    )			->			List[Any]:






         """simple docstring"""
         return False  # TF Logging is handled by Keras not the Trainer

     @property
     def 				__SCREAMING_SNAKE_CASE		(      self :       Optional[Any]    )			->			int:






         """simple docstring"""
         if self.per_gpu_train_batch_size:
             logger.warning(
                 """Using deprecated `--per_gpu_train_batch_size` argument which will be removed in a future """
                 """version. Using `--per_device_train_batch_size` is preferred."""    )
         a__      =       self.per_gpu_train_batch_size or self.per_device_train_batch_size
         return per_device_batch_size * self.n_replicas

     @property
     def 				__SCREAMING_SNAKE_CASE		(      self :       List[str]    )			->			int:






         """simple docstring"""
         if self.per_gpu_eval_batch_size:
             logger.warning(
                 """Using deprecated `--per_gpu_eval_batch_size` argument which will be removed in a future """
                 """version. Using `--per_device_eval_batch_size` is preferred."""    )
         a__      =       self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
         return per_device_batch_size * self.n_replicas






     @property
     def 				__SCREAMING_SNAKE_CASE		(      self :       str    )			->			int:






         """simple docstring"""
         requires_backends(self						,				["""tf"""]    )
         warnings.warn(
             """The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead."""						,				A						,				)
         return self._setup_strategy.num_replicas_in_sync






