



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


__lowerCamelCase								=      logging.get_logger(__name__)

__lowerCamelCase								=      {
    '''MCG-NJU/videomae-base''': '''https://huggingface.co/MCG-NJU/videomae-base/resolve/main/config.json''',
}


class 	snake_case_			(lowercase__	):




       """simple docstring"""






       _lowerCamelCase           =					"""videomae"""



       def __init__(  self  ,lowercase=224  ,lowercase=16  ,lowercase=3  ,lowercase=16  ,lowercase=2  ,lowercase=768  ,lowercase=12  ,lowercase=12  ,lowercase=3072  ,lowercase="gelu"  ,lowercase=0.0  ,lowercase=0.0  ,lowercase=0.02  ,lowercase=1E-12  ,lowercase=True  ,lowercase=True  ,lowercase=6  ,lowercase=384  ,lowercase=4  ,lowercase=1536  ,lowercase=True  ,**lowercase  ,):

             """simple docstring"""





             super().__init__(**lowercase)

             UpperCAmelCase_	:						Optional[int]					   =		image_size
             UpperCAmelCase_	:						Optional[Any]					   =		patch_size
             UpperCAmelCase_	:						Tuple					   =		num_channels
             UpperCAmelCase_	:						Optional[int]					   =		num_frames
             UpperCAmelCase_	:						str					   =		tubelet_size

             UpperCAmelCase_	:						Any					   =		hidden_size
             UpperCAmelCase_	:						List[str]					   =		num_hidden_layers
             UpperCAmelCase_	:						List[str]					   =		num_attention_heads
             UpperCAmelCase_	:						Union[str, Any]					   =		intermediate_size
             UpperCAmelCase_	:						List[str]					   =		hidden_act
             UpperCAmelCase_	:						Tuple					   =		hidden_dropout_prob
             UpperCAmelCase_	:						Optional[Any]					   =		attention_probs_dropout_prob
             UpperCAmelCase_	:						Optional[Any]					   =		initializer_range
             UpperCAmelCase_	:						Dict					   =		layer_norm_eps
             UpperCAmelCase_	:						Tuple					   =		qkv_bias
             UpperCAmelCase_	:						int					   =		use_mean_pooling

             UpperCAmelCase_	:						List[Any]					   =		decoder_num_attention_heads
             UpperCAmelCase_	:						Optional[int]					   =		decoder_hidden_size
             UpperCAmelCase_	:						Any					   =		decoder_num_hidden_layers
             UpperCAmelCase_	:						Dict					   =		decoder_intermediate_size
             UpperCAmelCase_	:						str					   =		norm_pix_loss





def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case     )  ->  list[int]:






      '''simple docstring'''







      if hue < 0 or hue > 3_6_0:
            raise Exception("hue should be between 0 and 360"     )

      if saturation < 0 or saturation > 1:
            raise Exception("saturation should be between 0 and 1"     )

      if value < 0 or value > 1:
            raise Exception("value should be between 0 and 1"     )

      UpperCAmelCase_	:						Tuple					   =		value * saturation
      UpperCAmelCase_	:						Union[str, Any]					   =		hue / 6_0
      UpperCAmelCase_	:						Tuple					   =		chroma * (1 - abs(hue_section % 2 - 1     ))
      UpperCAmelCase_	:						Tuple					   =		value - chroma

      if hue_section >= 0 and hue_section <= 1:
            UpperCAmelCase_	:						List[str]					   =		round(2_5_5 * (chroma + match_value)     )
            UpperCAmelCase_	:						str					   =		round(2_5_5 * (second_largest_component + match_value)     )
            UpperCAmelCase_	:						int					   =		round(2_5_5 * (match_value)     )
      elif hue_section > 1 and hue_section <= 2:
            UpperCAmelCase_	:						Union[str, Any]					   =		round(2_5_5 * (second_largest_component + match_value)     )
            UpperCAmelCase_	:						Union[str, Any]					   =		round(2_5_5 * (chroma + match_value)     )
            UpperCAmelCase_	:						int					   =		round(2_5_5 * (match_value)     )
      elif hue_section > 2 and hue_section <= 3:
            UpperCAmelCase_	:						List[str]					   =		round(2_5_5 * (match_value)     )
            UpperCAmelCase_	:						Any					   =		round(2_5_5 * (chroma + match_value)     )
            UpperCAmelCase_	:						Optional[int]					   =		round(2_5_5 * (second_largest_component + match_value)     )
      elif hue_section > 3 and hue_section <= 4:
            UpperCAmelCase_	:						str					   =		round(2_5_5 * (match_value)     )
            UpperCAmelCase_	:						Dict					   =		round(2_5_5 * (second_largest_component + match_value)     )
            UpperCAmelCase_	:						Optional[Any]					   =		round(2_5_5 * (chroma + match_value)     )
      elif hue_section > 4 and hue_section <= 5:
            UpperCAmelCase_	:						str					   =		round(2_5_5 * (second_largest_component + match_value)     )
            UpperCAmelCase_	:						Any					   =		round(2_5_5 * (match_value)     )
            UpperCAmelCase_	:						str					   =		round(2_5_5 * (chroma + match_value)     )
      else:
            UpperCAmelCase_	:						Optional[int]					   =		round(2_5_5 * (chroma + match_value)     )
            UpperCAmelCase_	:						Dict					   =		round(2_5_5 * (match_value)     )
            UpperCAmelCase_	:						Optional[int]					   =		round(2_5_5 * (second_largest_component + match_value)     )

      return [red, green, blue]







def  _snake_case			(							__snake_case       ,	__snake_case       ,	__snake_case     )  ->  list[float]:






      '''simple docstring'''







      if red < 0 or red > 2_5_5:
            raise Exception("red should be between 0 and 255"     )

      if green < 0 or green > 2_5_5:
            raise Exception("green should be between 0 and 255"     )

      if blue < 0 or blue > 2_5_5:
            raise Exception("blue should be between 0 and 255"     )

      UpperCAmelCase_	:						str					   =		red / 2_5_5
      UpperCAmelCase_	:						Dict					   =		green / 2_5_5
      UpperCAmelCase_	:						int					   =		blue / 2_5_5
      UpperCAmelCase_	:						Any					   =		max(__snake_case       ,	__snake_case       ,	__snake_case     )
      UpperCAmelCase_	:						Union[str, Any]					   =		value - min(__snake_case       ,	__snake_case       ,	__snake_case     )
      UpperCAmelCase_	:						Optional[Any]					   =		0 if value == 0 else chroma / value

      if chroma == 0:
            UpperCAmelCase_	:						Tuple					   =		0.0
      elif value == float_red:
            UpperCAmelCase_	:						List[str]					   =		6_0 * (0 + (float_green - float_blue) / chroma)
      elif value == float_green:
            UpperCAmelCase_	:						Union[str, Any]					   =		6_0 * (2 + (float_blue - float_red) / chroma)
      else:
            UpperCAmelCase_	:						Dict					   =		6_0 * (4 + (float_red - float_green) / chroma)

      UpperCAmelCase_	:						int					   =		(hue + 3_6_0) % 3_6_0

      return [hue, saturation, value]







def  _snake_case			(							__snake_case       ,	__snake_case     )  ->  bool:






      '''simple docstring'''







      UpperCAmelCase_	:						List[str]					   =		abs(hsv_a[0] - hsv_a[0]     ) < 0.2
      UpperCAmelCase_	:						Optional[Any]					   =		abs(hsv_a[1] - hsv_a[1]     ) < 0.002
      UpperCAmelCase_	:						Tuple					   =		abs(hsv_a[2] - hsv_a[2]     ) < 0.002

      return check_hue and check_saturation and check_value
