

'''simple docstring'''




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


_a				: Any 							=						logging.get_logger(__name__)

_a				: Dict 							=						{
    'ZinengTang/tvlt-base': 'https://huggingface.co/ZinengTang/tvlt-base/blob/main/config.json',
}



class        lowercase_	(		a ):

  '''simple docstring'''





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


    """simple docstring"""
    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}'''     )

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

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

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

    UpperCAmelCase													=	task_matching
    UpperCAmelCase													=	task_mae
    UpperCAmelCase													=	loss_type





'''simple docstring'''




from typing import List, Optional, Tuple, Union

from . import logging
from .import_utils import is_torch_available, is_torch_version


if is_torch_available():
  import torch

_a				: List[Any] 							=						logging.get_logger(__name__)  # pylint: disable=invalid-name

try:
  from torch._dynamo import allow_in_graph as maybe_allow_in_graph
except (ImportError, ModuleNotFoundError):


  def       lowerCamelCase__		(						cls      :   Dict						):
    return cls


def       lowerCamelCase__		(						SCREAMING_SNAKE_CASE      :   Union[Tuple, List]       ,   SCREAMING_SNAKE_CASE      :   Optional[Union[List["torch.Generator"], "torch.Generator"]] = None       ,   SCREAMING_SNAKE_CASE      :   Optional["torch.device"] = None       ,   SCREAMING_SNAKE_CASE      :   Optional["torch.dtype"] = None       ,   SCREAMING_SNAKE_CASE      :   Optional["torch.layout"] = None       ,   ):
  UpperCAmelCase													=	device
  UpperCAmelCase													=	shape[0]

  UpperCAmelCase													=	layout or torch.strided
  UpperCAmelCase													=	device or torch.device('cpu'						)

  if generator is not None:
    UpperCAmelCase													=	generator.device.type if not isinstance(SCREAMING_SNAKE_CASE       ,   SCREAMING_SNAKE_CASE						) else generator[0].device.type
    if gen_device_type != device.type and gen_device_type == "cpu":
      UpperCAmelCase													=	'cpu'
      if device != "mps":
        logger.info(
            f'''The passed generator was created on \'cpu\' even though a tensor on {device} was expected.'''
            f''' Tensors will be created on \'cpu\' and then moved to {device}. Note that one can probably'''
            f''' slighly speed up this function by passing a generator that was created on the {device} device.'''						)
    elif gen_device_type != device.type and gen_device_type == "cuda":
      raise ValueError(f'''Cannot generate a {device} tensor from a generator of type {gen_device_type}.'''						)

  if isinstance(SCREAMING_SNAKE_CASE       ,   SCREAMING_SNAKE_CASE						):
    UpperCAmelCase													=	(1,) + shape[1:]
    UpperCAmelCase													=	[
        torch.randn(SCREAMING_SNAKE_CASE       ,   generator=generator[i]       ,   device=SCREAMING_SNAKE_CASE       ,   dtype=SCREAMING_SNAKE_CASE       ,   layout=SCREAMING_SNAKE_CASE						)
        for i in range(SCREAMING_SNAKE_CASE						)
    ]
    UpperCAmelCase													=	torch.cat(SCREAMING_SNAKE_CASE       ,   dim=0						).to(SCREAMING_SNAKE_CASE						)
  else:
    UpperCAmelCase													=	torch.randn(SCREAMING_SNAKE_CASE       ,   generator=SCREAMING_SNAKE_CASE       ,   device=SCREAMING_SNAKE_CASE       ,   dtype=SCREAMING_SNAKE_CASE       ,   layout=SCREAMING_SNAKE_CASE						).to(SCREAMING_SNAKE_CASE						)

  return latents



def       lowerCamelCase__		(						SCREAMING_SNAKE_CASE      :   Tuple						):
  if is_torch_version('<'       ,   '2.0.0'						) or not hasattr(SCREAMING_SNAKE_CASE       ,   '_dynamo'						):
    return False
  return isinstance(SCREAMING_SNAKE_CASE       ,   torch._dynamo.eval_frame.OptimizedModule						)


