






# 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


__UpperCamelCase      :      Tuple     						=						logging.get_logger(__name__)


@dataclass
class        __UpperCamelCase    :







	def __init__(  self      :							Union[str, Any]       ,				_lowerCAmelCase      :							str=False       ,				_lowerCAmelCase      :							Optional[Any]=False       ,				_lowerCAmelCase      :							List[Any]=6.0       ,				_lowerCAmelCase      :							int=None       ,				_lowerCAmelCase      :							Dict=False       ,				_lowerCAmelCase      :							Union[str, Any]=False       ,				_lowerCAmelCase      :							Any=None       ,				_lowerCAmelCase      :							Tuple="fp4"       ,				_lowerCAmelCase      :							List[str]=False       ,				**_lowerCAmelCase      :							Any       ,				)		-> Dict:
		"""simple docstring"""







		__lowercase             =  load_in_abit
		__lowercase             =  load_in_abit
		__lowercase             =  llm_inta_threshold
		__lowercase             =  llm_inta_skip_modules
		__lowercase             =  llm_inta_enable_fpaa_cpu_offload
		__lowercase             =  llm_inta_has_fpaa_weight
		__lowercase             =  bnb_abit_quant_type
		__lowercase             =  bnb_abit_use_double_quant

		if bnb_abit_compute_dtype is None:
			__lowercase             =  torch.floataa
		elif isinstance(_lowerCAmelCase       ,				_lowerCAmelCase			):
			__lowercase             =  getattr(_lowerCAmelCase       ,				_lowerCAmelCase			)
		elif isinstance(_lowerCAmelCase       ,				torch.dtype			):
			__lowercase             =  bnb_abit_compute_dtype
		else:
			raise ValueError("""bnb_4bit_compute_dtype must be a string or a torch.dtype"""			)

		self.post_init()







	def  _a   (  self      :							Union[str, Any]			)		-> Optional[int]:
		"""simple docstring"""







		if not isinstance(self.llm_inta_threshold       ,				_lowerCAmelCase			):
			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       ,				_lowerCAmelCase			):
			raise ValueError("""llm_int8_skip_modules must be a list of strings"""			)
		if not isinstance(self.llm_inta_enable_fpaa_cpu_offload       ,				_lowerCAmelCase			):
			raise ValueError("""llm_int8_enable_fp32_cpu_offload must be a boolean"""			)

		if not isinstance(self.llm_inta_has_fpaa_weight       ,				_lowerCAmelCase			):
			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       ,				_lowerCAmelCase			):
			raise ValueError("""bnb_4bit_quant_type must be a string"""			)

		if not isinstance(self.bnb_abit_use_double_quant       ,				_lowerCAmelCase			):
			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  _a   (  self      :							Tuple			)		-> Dict:
		"""simple docstring"""







		return self.load_in_abit or self.load_in_abit







	def  _a   (  self      :							Optional[int]			)		-> Tuple:
		"""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  _a   (  cls      :							Dict       ,				_lowerCAmelCase      :							Optional[Any]       ,				_lowerCAmelCase      :							int       ,				**_lowerCAmelCase      :							List[str]			)		-> str:
		"""simple docstring"""







		__lowercase             =  cls(**_lowerCAmelCase			)

		__lowercase             =  []
		for key, value in kwargs.items():
			if hasattr(_lowerCAmelCase       ,				_lowerCAmelCase			):
				setattr(_lowerCAmelCase       ,				_lowerCAmelCase       ,				_lowerCAmelCase			)
				to_remove.append(_lowerCAmelCase			)
		for key in to_remove:
			kwargs.pop(_lowerCAmelCase       ,				_lowerCAmelCase			)

		if return_unused_kwargs:
			return config, kwargs
		else:
			return config







	def  _a   (  self      :							Union[str, Any]       ,				_lowerCAmelCase      :							Union[str, os.PathLike]			)		-> Tuple:
		"""simple docstring"""







		with open(_lowerCAmelCase       ,				"""w"""       ,				encoding="""utf-8"""			) as writer:
			__lowercase             =  self.to_dict()
			__lowercase             =  json.dumps(_lowerCAmelCase       ,				indent=2       ,				sort_keys=_lowerCAmelCase			) + """\n"""

			writer.write(_lowerCAmelCase			)







	def  _a   (  self      :							List[str]			)		-> Dict[str, Any]:
		"""simple docstring"""







		__lowercase             =  copy.deepcopy(self.__dict__			)
		__lowercase             =  str(output["""bnb_4bit_compute_dtype"""]			).split("""."""			)[1]

		return output







	def __repr__(  self      :							int			)		-> List[str]:
		"""simple docstring"""







		return F'{self.__class__.__name__} {self.to_json_string()}'







	def  _a   (  self      :							List[Any]       ,				_lowerCAmelCase      :							bool = True			)		-> str:
		"""simple docstring"""







		if use_diff is True:
			__lowercase             =  self.to_diff_dict()
		else:
			__lowercase             =  self.to_dict()
		return json.dumps(_lowerCAmelCase       ,				indent=2       ,				sort_keys=_lowerCAmelCase			) + "\n"







	def  _a   (  self      :							str			)		-> Dict[str, Any]:
		"""simple docstring"""







		__lowercase             =  self.to_dict()

		# get the default config dict
		__lowercase             =  BitsAndBytesConfig().to_dict()

		__lowercase             =  {}

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

		return serializable_config_dict









import numpy as np
from cva import COLOR_BGR2GRAY, CV_8UC3, cvtColor, filteraD, imread, imshow, waitKey





def 				snake_case  (     lowerCamelCase				,  lowerCamelCase				,  lowerCamelCase				,  lowerCamelCase				,  lowerCamelCase				,  lowerCamelCase					):




	'''simple docstring'''







	if (ksize % 2) == 0:
		__lowercase             =  ksize + 1
	__lowercase             =  np.zeros((ksize, ksize)				,  dtype=np.floataa					)

	# each value
	for y in range(lowerCamelCase					):
		for x in range(lowerCamelCase					):
			# distance from center
			__lowercase             =  x - ksize // 2
			__lowercase             =  y - ksize // 2

			# degree to radiant
			__lowercase             =  theta / 180 * np.pi
			__lowercase             =  np.cos(_theta					)
			__lowercase             =  np.sin(_theta					)

			# get kernel x
			__lowercase             =  cos_theta * px + sin_theta * py

			# get kernel y
			__lowercase             =  -sin_theta * px + cos_theta * py

			# fill kernel
			__lowercase             =  np.exp(
			    -(_x**2 + gamma**2 * _y**2) / (2 * sigma**2)					) * np.cos(2 * np.pi * _x / lambd + psi					)

	return gabor


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						# read original image
						__UpperCamelCase      :      List[Any]     						=						imread("""../image_data/lena.jpg""")
						# turn image in gray scale value
						__UpperCamelCase      :      Union[str, Any]     						=						cvtColor(img, COLOR_BGR2GRAY)

						# Apply multiple Kernel to detect edges
						__UpperCamelCase      :      Union[str, Any]     						=						np.zeros(gray.shape[:2])
						for theta in [0, 30, 60, 90, 120, 150]:
												__UpperCamelCase      :      Tuple     						=						gabor_filter_kernel(10, 8, theta, 10, 0, 0)
												out += filteraD(gray, CV_8UC3, kernel_aa)
						__UpperCamelCase      :      List[str]     						=						out / out.max() * 255
						__UpperCamelCase      :      List[str]     						=						out.astype(np.uinta)

						imshow("""Original""", gray)
						imshow("""Gabor filter with 20x20 mask and 6 directions""", out)

						waitKey(0)

