





'''simple docstring'''



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


_SCREAMING_SNAKE_CASE   =      logging.get_logger(__name__)






@dataclass
class 							__lowercase    :







	'''simple docstring'''

	def __init__(self       ,_lowerCamelCase=False       ,_lowerCamelCase=False       ,_lowerCamelCase=6.0       ,_lowerCamelCase=None       ,_lowerCamelCase=False       ,_lowerCamelCase=False       ,_lowerCamelCase=None       ,_lowerCamelCase="fp4"       ,_lowerCamelCase=False       ,**_lowerCamelCase       ,)							->							Tuple:







				'''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   _UpperCAmelCase       (self	)							->							Dict:







				'''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   _UpperCAmelCase       (self	)							->							str:







				'''simple docstring'''





				return self.load_in_abit or self.load_in_abit


	def   _UpperCAmelCase       (self	)							->							Dict:







				'''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   _UpperCAmelCase       (cls       ,_lowerCamelCase       ,_lowerCamelCase       ,**_lowerCamelCase	)							->							List[Any]:







				'''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   _UpperCAmelCase       (self       ,_lowerCamelCase	)							->							Optional[int]:







				'''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   _UpperCAmelCase       (self	)							->							Dict[str, Any]:







				'''simple docstring'''





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

				return output


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







				'''simple docstring'''





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


	def   _UpperCAmelCase       (self       ,_lowerCamelCase = 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   _UpperCAmelCase       (self	)							->							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












'''simple docstring'''



from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, logging


if is_torch_available():
	import torch


_SCREAMING_SNAKE_CASE   =      logging.get_logger(__name__)






class 							__lowercase    ( lowerCAmelCase__  ):







	'''simple docstring'''

	a      :			int     =    ["pixel_values"]


	def __init__(self       ,_lowerCamelCase = True       ,_lowerCamelCase = None       ,_lowerCamelCase = PILImageResampling.BILINEAR       ,_lowerCamelCase = True       ,_lowerCamelCase = None       ,_lowerCamelCase = True       ,_lowerCamelCase = 1 / 255       ,_lowerCamelCase = True       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,**_lowerCamelCase       ,)							->							None:







				'''simple docstring'''





				super().__init__(**_lowerCamelCase	)
				__lowercase			  =							size if size is not None else {'''shortest_edge''': 256}
				__lowercase			  =							get_size_dict(_lowerCamelCase       ,default_to_square=_lowerCamelCase	)
				__lowercase			  =							crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
				__lowercase			  =							get_size_dict(_lowerCamelCase       ,param_name='''crop_size'''	)
				__lowercase			  =							do_resize
				__lowercase			  =							size
				__lowercase			  =							resample
				__lowercase			  =							do_center_crop
				__lowercase			  =							crop_size
				__lowercase			  =							do_rescale
				__lowercase			  =							rescale_factor
				__lowercase			  =							do_normalize
				__lowercase			  =							image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
				__lowercase			  =							image_std if image_std is not None else IMAGENET_STANDARD_STD


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase = PILImageResampling.BICUBIC       ,_lowerCamelCase = None       ,**_lowerCamelCase       ,)							->							np.ndarray:







				'''simple docstring'''





				__lowercase			  =							get_size_dict(_lowerCamelCase       ,default_to_square=_lowerCamelCase	)
				if "shortest_edge" not in size:
							raise ValueError(f"The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}"	)
				__lowercase			  =							get_resize_output_image_size(_lowerCamelCase       ,size=size['''shortest_edge''']       ,default_to_square=_lowerCamelCase	)
				return resize(_lowerCamelCase       ,size=_lowerCamelCase       ,resample=_lowerCamelCase       ,data_format=_lowerCamelCase       ,**_lowerCamelCase	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase = None       ,**_lowerCamelCase       ,)							->							np.ndarray:







				'''simple docstring'''





				__lowercase			  =							get_size_dict(_lowerCamelCase	)
				if "height" not in size or "width" not in size:
							raise ValueError(f"The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}"	)
				return center_crop(_lowerCamelCase       ,size=(size['''height'''], size['''width'''])       ,data_format=_lowerCamelCase       ,**_lowerCamelCase	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase = None       ,**_lowerCamelCase	)							->							np.ndarray:







				'''simple docstring'''





				return rescale(_lowerCamelCase       ,scale=_lowerCamelCase       ,data_format=_lowerCamelCase       ,**_lowerCamelCase	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase = None       ,**_lowerCamelCase       ,)							->							np.ndarray:







				'''simple docstring'''





				return normalize(_lowerCamelCase       ,mean=_lowerCamelCase       ,std=_lowerCamelCase       ,data_format=_lowerCamelCase       ,**_lowerCamelCase	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = None       ,_lowerCamelCase = ChannelDimension.FIRST       ,**_lowerCamelCase       ,)							->							Any:







				'''simple docstring'''





				__lowercase			  =							do_resize if do_resize is not None else self.do_resize
				__lowercase			  =							size if size is not None else self.size
				__lowercase			  =							get_size_dict(_lowerCamelCase       ,default_to_square=_lowerCamelCase	)
				__lowercase			  =							resample if resample is not None else self.resample
				__lowercase			  =							do_center_crop if do_center_crop is not None else self.do_center_crop
				__lowercase			  =							crop_size if crop_size is not None else self.crop_size
				__lowercase			  =							get_size_dict(_lowerCamelCase       ,param_name='''crop_size'''	)
				__lowercase			  =							do_rescale if do_rescale is not None else self.do_rescale
				__lowercase			  =							rescale_factor if rescale_factor is not None else self.rescale_factor
				__lowercase			  =							do_normalize if do_normalize is not None else self.do_normalize
				__lowercase			  =							image_mean if image_mean is not None else self.image_mean
				__lowercase			  =							image_std if image_std is not None else self.image_std

				__lowercase			  =							make_list_of_images(_lowerCamelCase	)

				if not valid_images(_lowerCamelCase	):
							raise ValueError(
							    '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
							    '''torch.Tensor, tf.Tensor or jax.ndarray.'''	)

				if do_resize and size is None:
							raise ValueError('''Size must be specified if do_resize is True.'''	)

				if do_center_crop and crop_size is None:
							raise ValueError('''Crop size must be specified if do_center_crop is True.'''	)

				if do_rescale and rescale_factor is None:
							raise ValueError('''Rescale factor must be specified if do_rescale is True.'''	)

				if do_normalize and (image_mean is None or image_std is None):
							raise ValueError('''Image mean and std must be specified if do_normalize is True.'''	)

				# All transformations expect numpy arrays.
				__lowercase			  =							[to_numpy_array(_lowerCamelCase	) for image in images]

				if do_resize:
							__lowercase			  =							[self.resize(image=_lowerCamelCase       ,size=_lowerCamelCase       ,resample=_lowerCamelCase	) for image in images]

				if do_center_crop:
							__lowercase			  =							[self.center_crop(image=_lowerCamelCase       ,size=_lowerCamelCase	) for image in images]

				if do_rescale:
							__lowercase			  =							[self.rescale(image=_lowerCamelCase       ,scale=_lowerCamelCase	) for image in images]

				if do_normalize:
							__lowercase			  =							[self.normalize(image=_lowerCamelCase       ,mean=_lowerCamelCase       ,std=_lowerCamelCase	) for image in images]

				__lowercase			  =							[to_channel_dimension_format(_lowerCamelCase       ,_lowerCamelCase	) for image in images]

				__lowercase			  =							{'''pixel_values''': images}
				return BatchFeature(data=_lowerCamelCase       ,tensor_type=_lowerCamelCase	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase = None	)							->							str:







				'''simple docstring'''





				__lowercase			  =							outputs.logits

				# Resize logits and compute semantic segmentation maps
				if target_sizes is not None:
							if len(_lowerCamelCase	) != len(_lowerCamelCase	):
										raise ValueError(
										    '''Make sure that you pass in as many target sizes as the batch dimension of the logits'''	)

							if is_torch_tensor(_lowerCamelCase	):
										__lowercase			  =							target_sizes.numpy()

							__lowercase			  =							[]

							for idx in range(len(_lowerCamelCase	)	):
										__lowercase			  =							torch.nn.functional.interpolate(
										    logits[idx].unsqueeze(dim=0	)       ,size=target_sizes[idx]       ,mode='''bilinear'''       ,align_corners=_lowerCamelCase	)
										__lowercase			  =							resized_logits[0].argmax(dim=0	)
										semantic_segmentation.append(_lowerCamelCase	)
				else:
							__lowercase			  =							logits.argmax(dim=1	)
							__lowercase			  =							[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]	)]

				return semantic_segmentation





