




import random
from typing import List, Optional, Union

import numpy as np
import torch

from ..state import AcceleratorState
from .constants import CUDA_DISTRIBUTED_TYPES
from .dataclasses import DistributedType, RNGType
from .imports import is_npu_available, is_tpu_available, is_xpu_available


if is_tpu_available(check_device=False):
      import torch_xla.core.xla_model as xm

def       lowerCAmelCase_      (	lowerCamelCase:							int  ,					lowerCamelCase:							bool = False    )       ->      Optional[Any]:


      '''simple docstring'''




      if device_specific:
            seed += AcceleratorState().process_index
      random.seed(lowerCamelCase    )
      np.random.seed(lowerCamelCase    )
      torch.manual_seed(lowerCamelCase    )
      if is_xpu_available():
            torch.xpu.manual_seed_all(lowerCamelCase    )
      elif is_npu_available():
            torch.npu.manual_seed_all(lowerCamelCase    )
      else:
            torch.cuda.manual_seed_all(lowerCamelCase    )
      # ^^ safe to call this function even if cuda is not available
      if is_tpu_available():
            xm.set_rng_state(lowerCamelCase    )

def       lowerCAmelCase_      (	lowerCamelCase:							Optional[RNGType] = None  ,					lowerCamelCase:							Optional[torch.Generator] = None    )       ->      Optional[Any]:


      '''simple docstring'''




      if rng_type == RNGType.TORCH:
            lowerCamelCase__   	=					torch.get_rng_state()
      elif rng_type == RNGType.CUDA:
            lowerCamelCase__   	=					torch.cuda.get_rng_state()
      elif rng_type == RNGType.XLA:
            assert is_tpu_available(), "Can't synchronize XLA seeds on an environment without TPUs."
            lowerCamelCase__   	=					torch.tensor(xm.get_rng_state()    )
      elif rng_type == RNGType.NPU:
            assert is_npu_available(), "Can't synchronize NPU seeds on an environment without NPUs."
            lowerCamelCase__   	=					torch.npu.get_rng_state()
      elif rng_type == RNGType.XPU:
            assert is_xpu_available(), "Can't synchronize XPU seeds on an environment without XPUs."
            lowerCamelCase__   	=					torch.xpu.get_rng_state()
      elif rng_type == RNGType.GENERATOR:
            assert generator is not None, "Need a generator to synchronize its seed."
            lowerCamelCase__   	=					generator.get_state()

      # Broadcast the rng state from device 0 to other devices
      lowerCamelCase__   	=					AcceleratorState()
      if state.distributed_type == DistributedType.TPU:
            lowerCamelCase__   	=					rng_state.to(xm.xla_device()    )
            xm.collective_broadcast([rng_state]    )
            xm.mark_step()
            lowerCamelCase__   	=					rng_state.cpu()
      elif (
          state.distributed_type in CUDA_DISTRIBUTED_TYPES
          or state.distributed_type == DistributedType.MULTI_NPU
          or state.distributed_type == DistributedType.MULTI_XPU
      ):
            lowerCamelCase__   	=					rng_state.to(state.device    )
            torch.distributed.broadcast(lowerCamelCase  ,					0    )
            lowerCamelCase__   	=					rng_state.cpu()
      elif state.distributed_type == DistributedType.MULTI_CPU:
            torch.distributed.broadcast(lowerCamelCase  ,					0    )

      # Set the broadcast rng state
      if rng_type == RNGType.TORCH:
            torch.set_rng_state(lowerCamelCase    )
      elif rng_type == RNGType.CUDA:
            torch.cuda.set_rng_state(lowerCamelCase    )
      elif rng_type == RNGType.NPU:
            torch.npu.set_rng_state(lowerCamelCase    )
      elif rng_type == RNGType.XPU:
            torch.xpu.set_rng_state(lowerCamelCase    )
      elif rng_type == RNGType.XLA:
            xm.set_rng_state(rng_state.item()    )
      elif rng_type == RNGType.GENERATOR:
            generator.set_state(lowerCamelCase    )


def       lowerCAmelCase_      (	lowerCamelCase:							List[Union[str, RNGType]]  ,					lowerCamelCase:							Optional[torch.Generator] = None    )       ->      int:


      '''simple docstring'''




      for rng_type in rng_types:
            synchronize_rng_state(RNGType(lowerCamelCase    )  ,					generator=lowerCamelCase    )





from ...configuration_utils import PretrainedConfig
from ...utils import logging


__SCREAMING_SNAKE_CASE     : str      =logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE     : Any      ={
    """ZinengTang/tvlt-base""": """https://huggingface.co/ZinengTang/tvlt-base/blob/main/config.json""",
}






class       A      (		_lowerCAmelCase		):
     """simple docstring"""

     _snake_case:						str  ="tvlt"




     def __init__(     self	: List[Any]						,	A__	: List[str]=2_2_4						,	A__	: Optional[int]=2_0_4_8						,	A__	: str=1_2_8						,	A__	: Union[str, Any]=[1_6, 1_6]						,	A__	: List[Any]=[1_6, 1_6]						,	A__	: int=3						,	A__	: Optional[int]=1						,	A__	: Tuple=8						,	A__	: Tuple=7_6_8						,	A__	: List[str]=1_2						,	A__	: Tuple=1_2						,	A__	: int=3_0_7_2						,	A__	: Tuple="gelu"						,	A__	: str=0.0						,	A__	: Dict=0.0						,	A__	: Any=0.02						,	A__	: int=1E-6						,	A__	: List[str]=True						,	A__	: List[str]=False						,	A__	: Optional[Any]=1_6						,	A__	: Optional[Any]=5_1_2						,	A__	: List[Any]=8						,	A__	: Any=2_0_4_8						,	A__	: List[Any]=0.75						,	A__	: List[Any]=0.15						,	A__	: str="frame-level"						,	A__	: Union[str, Any]=True						,	A__	: Optional[int]=True						,	A__	: Optional[Any]="classification"						,	**A__	: int						,	)					->							Tuple:
           super().__init__(**A__      )

           if audio_mask_type not in ("frame-level", "patch_level"):
                 raise ValueError(
                     'audio_mask_type must be one of two acceptable strategies - {\'frame_level\', \'patch-level\') '
                     F"""got {audio_mask_type}"""      )

           lowerCamelCase__   	=					image_size
           lowerCamelCase__   	=					spectrogram_length
           lowerCamelCase__   	=					frequency_length
           lowerCamelCase__   	=					image_patch_size
           lowerCamelCase__   	=					audio_patch_size
           lowerCamelCase__   	=					num_image_channels
           lowerCamelCase__   	=					num_audio_channels
           lowerCamelCase__   	=					num_frames

           lowerCamelCase__   	=					hidden_size
           lowerCamelCase__   	=					num_hidden_layers
           lowerCamelCase__   	=					num_attention_heads
           lowerCamelCase__   	=					intermediate_size
           lowerCamelCase__   	=					hidden_act
           lowerCamelCase__   	=					hidden_dropout_prob
           lowerCamelCase__   	=					attention_probs_dropout_prob
           lowerCamelCase__   	=					initializer_range
           lowerCamelCase__   	=					layer_norm_eps
           lowerCamelCase__   	=					qkv_bias
           lowerCamelCase__   	=					use_mean_pooling

           lowerCamelCase__   	=					decoder_num_attention_heads
           lowerCamelCase__   	=					decoder_hidden_size
           lowerCamelCase__   	=					decoder_num_hidden_layers
           lowerCamelCase__   	=					decoder_intermediate_size
           lowerCamelCase__   	=					pixel_mask_ratio
           lowerCamelCase__   	=					audio_mask_ratio
           lowerCamelCase__   	=					audio_mask_type

           lowerCamelCase__   	=					task_matching
           lowerCamelCase__   	=					task_mae
           lowerCamelCase__   	=					loss_type