
'''simple docstring'''





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


a__						:				Union[str, Any]           =    logging.get_logger(__name__)

if is_tf_available():
 import tensorflow as tf


@dataclass
class 	UpperCamelCase__					(      SCREAMING_SNAKE_CASE):
 UpperCAmelCase__      :      List[Any]  			=   'tf'
 UpperCAmelCase__      :      Optional[str]  			=   field(
     default=SCREAMING_SNAKE_CASE ,       metadata={'help': 'Name of TPU'} ,       )

 UpperCAmelCase__      :      Optional[str]  			=   field(
     default=SCREAMING_SNAKE_CASE ,       metadata={'help': 'Zone of TPU'} ,       )

 UpperCAmelCase__      :      Optional[str]  			=   field(
     default=SCREAMING_SNAKE_CASE ,       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=SCREAMING_SNAKE_CASE ,       metadata={'help': 'Whether to activate the XLA compilation or not'})






 @cached_property
 def 		lowercase_  (     self					:Any     )			->     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 		lowercase_  (     self					:Dict     )			->     "tf.distribute.Strategy":







       '''simple docstring'''



       requires_backends(self		,			['tf']     )
       return self._setup_strategy






 @property
 def 		lowercase_  (     self					:int     )			->     int:







       '''simple docstring'''



       requires_backends(self		,			['tf']     )
       return self._setup_strategy.num_replicas_in_sync






 @property
 def 		lowercase_  (     self					:List[str]     )			->     Union[str, Any]:







       '''simple docstring'''



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






 @property
 def 		lowercase_  (     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 		lowercase_  (     self					:Any     )			->     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 		lowercase_  (     self					:Dict     )			->     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








'''simple docstring'''





import unittest

import torch

from diffusers import DDIMScheduler, TextToVideoZeroPipeline
from diffusers.utils import load_pt, require_torch_gpu, slow

from ..test_pipelines_common import assert_mean_pixel_difference


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






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







       '''simple docstring'''



       __A    		=     'runwayml/stable-diffusion-v1-5'
       __A    		=     TextToVideoZeroPipeline.from_pretrained(_A		,			torch_dtype=torch.floataa     ).to('cuda'     )
       __A    		=     DDIMScheduler.from_config(pipe.scheduler.config     )
       __A    		=     torch.Generator(device='cuda'     ).manual_seed(0     )

       __A    		=     'A bear is playing a guitar on Times Square'
       __A    		=     pipe(prompt=_A		,			generator=_A     ).images

       __A    		=     load_pt(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text-to-video/A bear is playing a guitar on Times Square.pt'     )

       assert_mean_pixel_difference(_A		,			_A     )






