





# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import copy
import importlib.metadata
import json
import os
from dataclasses import dataclass
from typing import Any, Dict, Union

from packaging import version

from ..utils import is_torch_available, logging


if is_torch_available():
							import torch


__lowerCAmelCase :str     =    logging.get_logger(__name__)






@dataclass
class        _a:







		def __init__(    self ,						__snake_case=False ,						__snake_case=False ,						__snake_case=6.0 ,						__snake_case=None ,						__snake_case=False ,						__snake_case=False ,						__snake_case=None ,						__snake_case="fp4" ,						__snake_case=False ,						**__snake_case ,						)      ->      Optional[Any]:


							'''simple docstring'''

							_snake_case       :					Optional[Any]				       =   load_in_abit
							_snake_case       :					Any				       =   load_in_abit
							_snake_case       :					List[Any]				       =   llm_inta_threshold
							_snake_case       :					str				       =   llm_inta_skip_modules
							_snake_case       :					Optional[Any]				       =   llm_inta_enable_fpaa_cpu_offload
							_snake_case       :					Any				       =   llm_inta_has_fpaa_weight
							_snake_case       :					Tuple				       =   bnb_abit_quant_type
							_snake_case       :					List[str]				       =   bnb_abit_use_double_quant

							if bnb_abit_compute_dtype is None:
												_snake_case       :					List[Any]				       =   torch.floataa
							elif isinstance(__snake_case ,						__snake_case				):
												_snake_case       :					Optional[int]				       =   getattr(__snake_case ,						__snake_case				)
							elif isinstance(__snake_case ,						torch.dtype				):
												_snake_case       :					Dict				       =   bnb_abit_compute_dtype
							else:
												raise ValueError("bnb_4bit_compute_dtype must be a string or a torch.dtype"				)

							self.post_init()







		def        lowercase       (    self				)      ->      Tuple:


							'''simple docstring'''

							if not isinstance(self.llm_inta_threshold ,						__snake_case				):
												raise ValueError("llm_int8_threshold must be a float"				)

							if self.llm_inta_skip_modules is not None and not isinstance(self.llm_inta_skip_modules ,						__snake_case				):
												raise ValueError("llm_int8_skip_modules must be a list of strings"				)
							if not isinstance(self.llm_inta_enable_fpaa_cpu_offload ,						__snake_case				):
												raise ValueError("llm_int8_enable_fp32_cpu_offload must be a boolean"				)

							if not isinstance(self.llm_inta_has_fpaa_weight ,						__snake_case				):
												raise ValueError("llm_int8_has_fp16_weight must be a boolean"				)

							if self.bnb_abit_compute_dtype is not None and not isinstance(self.bnb_abit_compute_dtype ,						torch.dtype				):
												raise ValueError("bnb_4bit_compute_dtype must be torch.dtype"				)

							if not isinstance(self.bnb_abit_quant_type ,						__snake_case				):
												raise ValueError("bnb_4bit_quant_type must be a string"				)

							if not isinstance(self.bnb_abit_use_double_quant ,						__snake_case				):
												raise ValueError("bnb_4bit_use_double_quant must be a boolean"				)

							if self.load_in_abit and not version.parse(importlib.metadata.version("bitsandbytes"				)				) >= version.parse(
							    "0.39.0"				):
												raise ValueError(
												    "4 bit quantization requires bitsandbytes>=0.39.0 - please upgrade your bitsandbytes version"				)







		def        lowercase       (    self				)      ->      Optional[int]:


							'''simple docstring'''

							return self.load_in_abit or self.load_in_abit







		def        lowercase       (    self				)      ->      Optional[int]:


							'''simple docstring'''

							if self.load_in_abit:
												return "llm_int8"
							elif self.load_in_abit and self.bnb_abit_quant_type == "fp4":
												return "fp4"
							elif self.load_in_abit and self.bnb_abit_quant_type == "nf4":
												return "nf4"
							else:
												return None







		@classmethod
		def        lowercase       (    cls ,						__snake_case ,						__snake_case ,						**__snake_case				)      ->      List[Any]:


							'''simple docstring'''

							_snake_case       :					List[Any]				       =   cls(**__snake_case				)

							_snake_case       :					Optional[Any]				       =   []
							for key, value in kwargs.items():
												if hasattr(__snake_case ,						__snake_case				):
																	setattr(__snake_case ,						__snake_case ,						__snake_case				)
																	to_remove.append(__snake_case				)
							for key in to_remove:
												kwargs.pop(__snake_case ,						__snake_case				)

							if return_unused_kwargs:
												return config, kwargs
							else:
												return config







		def        lowercase       (    self ,						__snake_case				)      ->      Optional[Any]:


							'''simple docstring'''

							with open(__snake_case ,						"w" ,						encoding="utf-8"				) as writer:
												_snake_case       :					List[Any]				       =   self.to_dict()
												_snake_case       :					Optional[Any]				       =   json.dumps(__snake_case ,						indent=2 ,						sort_keys=__snake_case				) + "\n"

												writer.write(__snake_case				)







		def        lowercase       (    self				)      ->      Dict[str, Any]:


							'''simple docstring'''

							_snake_case       :					Any				       =   copy.deepcopy(self.__dict__				)
							_snake_case       :					List[str]				       =   str(output["bnb_4bit_compute_dtype"]				).split("."				)[1]

							return output







		def __repr__(    self				)      ->      Optional[Any]:


							'''simple docstring'''

							return f"""{self.__class__.__name__} {self.to_json_string()}"""







		def        lowercase       (    self ,						__snake_case = True				)      ->      str:


							'''simple docstring'''

							if use_diff is True:
												_snake_case       :					Union[str, Any]				       =   self.to_diff_dict()
							else:
												_snake_case       :					Tuple				       =   self.to_dict()
							return json.dumps(__snake_case ,						indent=2 ,						sort_keys=__snake_case				) + "\n"







		def        lowercase       (    self				)      ->      Dict[str, Any]:


							'''simple docstring'''

							_snake_case       :					Tuple				       =   self.to_dict()

							# get the default config dict
							_snake_case       :					str				       =   BitsAndBytesConfig().to_dict()

							_snake_case       :					Any				       =   {}

							# only serialize values that differ from the default config
							for key, value in config_dict.items():
												if value != default_config_dict[key]:
																	_snake_case       :					List[Any]				       =   value

							return serializable_config_dict






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


__lowerCAmelCase :Tuple     =    logging.get_logger(__name__)

__lowerCAmelCase :int     =    {
    'facebook/timesformer': 'https://huggingface.co/facebook/timesformer/resolve/main/config.json',
}






class        _a(    __A    ):
		lowerCamelCase__     :Optional[Any]   				=		'timesformer'







		def __init__(    self ,						__snake_case=2_2_4 ,						__snake_case=1_6 ,						__snake_case=3 ,						__snake_case=8 ,						__snake_case=7_6_8 ,						__snake_case=1_2 ,						__snake_case=1_2 ,						__snake_case=3_0_7_2 ,						__snake_case="gelu" ,						__snake_case=0.0 ,						__snake_case=0.0 ,						__snake_case=0.02 ,						__snake_case=1E-6 ,						__snake_case=True ,						__snake_case="divided_space_time" ,						__snake_case=0 ,						**__snake_case ,						)      ->      str:


							'''simple docstring'''

							super().__init__(**__snake_case				)

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

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

							_snake_case       :					List[str]				       =   attention_type
							_snake_case       :					Optional[int]				       =   drop_path_rate