






"""simple docstring"""






import logging
import re

import pytorch_quantization
import pytorch_quantization.nn as quant_nn
import torch
from pytorch_quantization import calib
from pytorch_quantization.tensor_quant import QuantDescriptor


SCREAMING_SNAKE_CASE						:						List[Any]					   =       logging.getLogger(__name__)

SCREAMING_SNAKE_CASE						:						List[str]					   =       50  # max width of layer names
SCREAMING_SNAKE_CASE						:						Dict					   =       70  # max width of quantizer names



def  __lowerCamelCase					(					lowerCAmelCase__				):
				A__							 =       parser.add_argument_group('quant_trainer arguments'				)
				group.add_argument('--wprec'       ,type=lowerCAmelCase__       ,default=8       ,help='weight precision'				)
				group.add_argument('--aprec'       ,type=lowerCAmelCase__       ,default=8       ,help='activation precision'				)
				group.add_argument('--quant-per-tensor'       ,action='store_true'       ,help='per tensor weight scaling'				)
				group.add_argument('--quant-disable'       ,action='store_true'       ,help='disable all quantizers'				)
				group.add_argument('--quant-disable-embeddings'       ,action='store_true'       ,help='disable all embeddings quantizers'				)
				group.add_argument('--quant-disable-keyword'       ,type=lowerCAmelCase__       ,nargs='+'       ,help='disable quantizers by keyword'				)
				group.add_argument('--quant-disable-layer-module'       ,type=lowerCAmelCase__       ,help='disable quantizers by keyword under layer.'				)
				group.add_argument('--quant-enable-layer-module'       ,type=lowerCAmelCase__       ,help='enable quantizers by keyword under layer'				)
				group.add_argument('--calibrator'       ,default='max'       ,help='which quantization range calibrator to use'				)
				group.add_argument('--percentile'       ,default=lowerCAmelCase__       ,type=lowerCAmelCase__       ,help='percentile for PercentileCalibrator'				)
				group.add_argument('--fuse-qkv'       ,action='store_true'       ,help='use the same scale factor for qkv'				)
				group.add_argument('--clip-gelu'       ,metavar='N'       ,type=lowerCAmelCase__       ,help='clip gelu output maximum value to N'				)
				group.add_argument(
				    '--recalibrate-weights'       ,action='store_true'       ,help=(
				        'recalibrate weight amaxes by taking the max of the weights.'
				        ' amaxes will be computed with the current quantization granularity (axis).'
				    )       ,)



def  __lowerCamelCase					(					lowerCAmelCase__				):

				if args.calibrator == "max":
								A__							 =       'max'
				elif args.calibrator == "percentile":
								if args.percentile is None:
												raise ValueError('Specify --percentile when using percentile calibrator'				)
								A__							 =       'histogram'
				elif args.calibrator == "mse":
								A__							 =       'histogram'
				else:
								raise ValueError(f'''Invalid calibrator {args.calibrator}'''				)

				A__							 =       QuantDescriptor(num_bits=args.aprec       ,calib_method=lowerCAmelCase__				)
				A__							 =       QuantDescriptor(num_bits=args.wprec       ,axis=(None if args.quant_per_tensor else (0,))				)
				quant_nn.QuantLinear.set_default_quant_desc_input(lowerCAmelCase__				)
				quant_nn.QuantLinear.set_default_quant_desc_weight(lowerCAmelCase__				)



def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__=False       ,lowerCAmelCase__=False				):
				logger.info('Configuring Model for Quantization'				)
				logger.info(f'''using quantization package {pytorch_quantization.__file__}'''				)

				if not calib:
								if args.quant_disable_embeddings:
												set_quantizer_by_name(lowerCAmelCase__       ,['embeddings']       ,which='weight'       ,_disabled=lowerCAmelCase__				)

								if args.quant_disable:
												set_quantizer_by_name(lowerCAmelCase__       ,['']       ,_disabled=lowerCAmelCase__				)

								if args.quant_disable_keyword:
												set_quantizer_by_name(lowerCAmelCase__       ,args.quant_disable_keyword       ,_disabled=lowerCAmelCase__				)

								if args.quant_disable_layer_module:
												set_quantizer_by_name(lowerCAmelCase__       ,[r'layer.\d+.' + args.quant_disable_layer_module]       ,_disabled=lowerCAmelCase__				)

								if args.quant_enable_layer_module:
												set_quantizer_by_name(lowerCAmelCase__       ,[r'layer.\d+.' + args.quant_enable_layer_module]       ,_disabled=lowerCAmelCase__				)

								if args.recalibrate_weights:
												recalibrate_weights(lowerCAmelCase__				)

								if args.fuse_qkv:
												fuse_qkv(lowerCAmelCase__       ,lowerCAmelCase__				)

				if args.clip_gelu:
								clip_gelu(lowerCAmelCase__       ,args.clip_gelu				)

				# if args.local_rank in [-1, 0] and not calib:
				print_quant_summary(lowerCAmelCase__				)



def  __lowerCamelCase					(					lowerCAmelCase__				):
				logger.info('Enabling Calibration'				)
				for name, module in model.named_modules():
								if name.endswith('_quantizer'				):
												if module._calibrator is not None:
																module.disable_quant()
																module.enable_calib()
												else:
																module.disable()
												logger.info(f'''{name:80}: {module}'''				)



def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__				):
				logger.info('Loading calibrated amax'				)
				for name, module in model.named_modules():
								if name.endswith('_quantizer'				):
												if module._calibrator is not None:
																if isinstance(module._calibrator       ,calib.MaxCalibrator				):
																				module.load_calib_amax()
																else:
																				module.load_calib_amax('percentile'       ,percentile=args.percentile				)
																module.enable_quant()
																module.disable_calib()
												else:
																module.enable()
				model.cuda()
				print_quant_summary(lowerCAmelCase__				)



def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__				):

				def fusea(lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__				):
								for mod in [qq, qk, qv]:
												if not hasattr(lowerCAmelCase__       ,'_amax'				):
																print('          WARNING: NO AMAX BUFFER'				)
																return
								A__							 =       qq._amax.detach().item()
								A__							 =       qk._amax.detach().item()
								A__							 =       qv._amax.detach().item()

								A__							 =       max(lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__				)
								qq._amax.fill_(lowerCAmelCase__				)
								qk._amax.fill_(lowerCAmelCase__				)
								qv._amax.fill_(lowerCAmelCase__				)
								logger.info(f'''          q={q:5.2f} k={k:5.2f} v={v:5.2f} -> {amax:5.2f}'''				)

				for name, mod in model.named_modules():
								if name.endswith('.attention.self'				):
												logger.info(f'''FUSE_QKV: {name:{name_width}}'''				)
												fusea(mod.matmul_q_input_quantizer       ,mod.matmul_k_input_quantizer       ,mod.matmul_v_input_quantizer				)
												if args.quant_per_tensor:
																fusea(mod.query._weight_quantizer       ,mod.key._weight_quantizer       ,mod.value._weight_quantizer				)



def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__				):

				for name, mod in model.named_modules():
								if name.endswith('.output.dense'				) and not name.endswith('attention.output.dense'				):
												A__							 =       mod._input_quantizer._amax.data.detach().item()
												mod._input_quantizer._amax.data.detach().clamp_(max=lowerCAmelCase__				)
												A__							 =       mod._input_quantizer._amax.data.detach().item()
												logger.info(f'''CLIP_GELU: {name:{name_width}} amax: {amax_init:5.2f} -> {amax:5.2f}'''				)



def  __lowerCamelCase					(					lowerCAmelCase__				):

				for name, mod in model.named_modules():
								if hasattr(lowerCAmelCase__       ,'_weight_quantizer'				) and mod._weight_quantizer.axis is not None:
												A__							 =       mod.weight.shape[0]
												A__							 =       mod._weight_quantizer._amax.detach()
												A__							 =       torch.ones(lowerCAmelCase__       ,dtype=amax.dtype       ,device=amax.device				) * amax
												print(f'''expanding {name} {amax} -> {mod._weight_quantizer._amax}'''				)



def  __lowerCamelCase					(					lowerCAmelCase__				):

				for name, mod in model.named_modules():
								if hasattr(lowerCAmelCase__       ,'_weight_quantizer'				):
												if not hasattr(mod.weight_quantizer       ,'_amax'				):
																print('RECALIB: {name:{name_width}} WARNING: NO AMAX BUFFER'				)
																continue

												# determine which axes to reduce across
												# e.g. a 4D tensor quantized per axis 0 should reduce over (1,2,3)
												A__							 =       set() if mod._weight_quantizer.axis is None else set(mod._weight_quantizer.axis				)
												A__							 =       set(range(len(mod.weight.size()				)				)				) - axis_set
												A__							 =       pytorch_quantization.utils.reduce_amax(mod.weight       ,axis=lowerCAmelCase__       ,keepdims=lowerCAmelCase__				).detach()
												logger.info(f'''RECALIB: {name:{name_width}} {mod._weight_quantizer._amax.flatten()} -> {amax.flatten()}'''				)
												A__							 =       amax



def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__=25       ,lowerCAmelCase__=180       ,lowerCAmelCase__=None				):

				if ignore is None:
								A__							 =       []
				elif not isinstance(lowerCAmelCase__       ,lowerCAmelCase__				):
								A__							 =       [ignore]

				A__							 =       0
				for name, mod in model.named_modules():
								if not hasattr(lowerCAmelCase__       ,'weight'				):
												continue
								A__							 =       max(lowerCAmelCase__       ,len(lowerCAmelCase__				)				)

				for name, mod in model.named_modules():
								A__							 =       getattr(lowerCAmelCase__       ,'_input_quantizer'       ,lowerCAmelCase__				)
								A__							 =       getattr(lowerCAmelCase__       ,'_weight_quantizer'       ,lowerCAmelCase__				)
								if not hasattr(lowerCAmelCase__       ,'weight'				):
												continue
								if type(lowerCAmelCase__				) in ignore:
												continue
								if [True for s in ignore if type(lowerCAmelCase__				) is str and s in name]:
												continue
								A__							 =       f'''Act:{input_q.extra_repr()}'''
								A__							 =       f'''Wgt:{weight_q.extra_repr()}'''
								A__							 =       f'''{name:{name_width}} {act_str} {wgt_str}'''
								if len(lowerCAmelCase__				) <= line_width:
												logger.info(lowerCAmelCase__				)
								else:
												logger.info(f'''{name:{name_width}} {act_str}'''				)
												logger.info(f'''{'  ':{name_width}} {wgt_str}'''				)



def  __lowerCamelCase					(					lowerCAmelCase__				):
				A__							 =       0
				for name, mod in model.named_modules():
								if isinstance(lowerCAmelCase__       ,pytorch_quantization.nn.TensorQuantizer				):
												print(f'''{name:80} {mod}'''				)
												count += 1
				print(f'''{count} TensorQuantizers found in model'''				)



def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__				):
				A__							 =       getattr(lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__				)
				if quantizer_mod is not None:
								assert hasattr(lowerCAmelCase__       ,lowerCAmelCase__				)
								setattr(lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__				)
				else:
								logger.warning(f'''{name} has no {quantizer}'''				)



def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__="both"       ,**lowerCAmelCase__				):
				A__							 =       f'''Warning: changing {which} quantizers of {name:{qname_width}}'''
				for k, v in kwargs.items():
								s += f''' {k}={v}'''
								if which in ["input", "both"]:
												set_quantizer(lowerCAmelCase__       ,lowerCAmelCase__       ,'_input_quantizer'       ,lowerCAmelCase__       ,lowerCAmelCase__				)
								if which in ["weight", "both"]:
												set_quantizer(lowerCAmelCase__       ,lowerCAmelCase__       ,'_weight_quantizer'       ,lowerCAmelCase__       ,lowerCAmelCase__				)
				logger.info(lowerCAmelCase__				)







def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__       ,**lowerCAmelCase__				):

				for name, mod in model.named_modules():
								if hasattr(lowerCAmelCase__       ,'_input_quantizer'				) or hasattr(lowerCAmelCase__       ,'_weight_quantizer'				):
												for n in names:
																if re.search(lowerCAmelCase__       ,lowerCAmelCase__				):
																				set_quantizers(lowerCAmelCase__       ,lowerCAmelCase__       ,**lowerCAmelCase__				)
								elif name.endswith('_quantizer'				):
												for n in names:
																if re.search(lowerCAmelCase__       ,lowerCAmelCase__				):
																				A__							 =       f'''Warning: changing {name:{name_width}}'''
																				for k, v in kwargs.items():
																								s += f''' {k}={v}'''
																								setattr(lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__				)
																				logger.info(lowerCAmelCase__				)










"""simple docstring"""






import io
import math
from typing import Dict, Optional, Union

import numpy as np
from huggingface_hub import hf_hub_download

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import convert_to_rgb, normalize, to_channel_dimension_format, to_pil_image
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    get_image_size,
    infer_channel_dimension_format,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_vision_available, logging
from ...utils.import_utils import requires_backends


if is_vision_available():
					import textwrap

					from PIL import Image, ImageDraw, ImageFont

if is_torch_available():
					import torch

					from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
					SCREAMING_SNAKE_CASE						:						str					   =       False


SCREAMING_SNAKE_CASE						:						str					   =       logging.get_logger(__name__)
SCREAMING_SNAKE_CASE						:						Optional[Any]					   =       '''ybelkada/fonts'''



def  __lowerCamelCase					(					):
				if is_torch_available() and not is_torch_greater_or_equal_than_1_11:
								raise ImportError(
								    f'''You are using torch=={torch.__version__}, but torch>=1.11.0 is required to use '''
								    'Pix2StructImageProcessor. Please upgrade torch.'				)



def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__				):
				requires_backends(lowerCAmelCase__       ,['torch']				)
				_check_torch_version()

				A__							 =       image_tensor.unsqueeze(0				)
				A__							 =       torch.nn.functional.unfold(lowerCAmelCase__       ,(patch_height, patch_width)       ,stride=(patch_height, patch_width)				)
				A__							 =       patches.reshape(image_tensor.size(0				)       ,image_tensor.size(1				)       ,lowerCAmelCase__       ,lowerCAmelCase__       ,-1				)
				A__							 =       patches.permute(0       ,4       ,2       ,3       ,1				).reshape(
				    image_tensor.size(2				) // patch_height       ,image_tensor.size(3				) // patch_width       ,image_tensor.size(1				) * patch_height * patch_width       ,)
				return patches.unsqueeze(0				)



def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__ = 36       ,lowerCAmelCase__ = "black"       ,lowerCAmelCase__ = "white"       ,lowerCAmelCase__ = 5       ,lowerCAmelCase__ = 5       ,lowerCAmelCase__ = 5       ,lowerCAmelCase__ = 5       ,lowerCAmelCase__ = None       ,lowerCAmelCase__ = None       ,):
				requires_backends(lowerCAmelCase__       ,'vision'				)
				# Add new lines so that each line is no more than 80 characters.

				A__							 =       textwrap.TextWrapper(width=80				)
				A__							 =       wrapper.wrap(text=lowerCAmelCase__				)
				A__							 =       '\n'.join(lowerCAmelCase__				)

				if font_bytes is not None and font_path is None:
								A__							 =       io.BytesIO(lowerCAmelCase__				)
				elif font_path is not None:
								A__							 =       font_path
				else:
								A__							 =       hf_hub_download(lowerCAmelCase__       ,'Arial.TTF'				)
				A__							 =       ImageFont.truetype(lowerCAmelCase__       ,encoding='UTF-8'       ,size=lowerCAmelCase__				)

				# Use a temporary canvas to determine the width and height in pixels when
				# rendering the text.
				A__							 =       ImageDraw.Draw(Image.new('RGB'       ,(1, 1)       ,lowerCAmelCase__				)				)
				A__ ,			A__ ,			A__ ,			A__							 =       temp_draw.textbbox((0, 0)       ,lowerCAmelCase__       ,lowerCAmelCase__				)

				# Create the actual image with a bit of padding around the text.
				A__							 =       text_width + left_padding + right_padding
				A__							 =       text_height + top_padding + bottom_padding
				A__							 =       Image.new('RGB'       ,(image_width, image_height)       ,lowerCAmelCase__				)
				A__							 =       ImageDraw.Draw(lowerCAmelCase__				)
				draw.text(xy=(left_padding, top_padding)       ,text=lowerCAmelCase__       ,fill=lowerCAmelCase__       ,font=lowerCAmelCase__				)
				return image



def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__       ,**lowerCAmelCase__				):
				requires_backends(lowerCAmelCase__       ,'vision'				)

				# Convert to PIL image if necessary
				A__							 =       to_pil_image(lowerCAmelCase__				)

				A__							 =       render_text(lowerCAmelCase__       ,**lowerCAmelCase__				)
				A__							 =       max(header_image.width       ,image.width				)

				A__							 =       int(image.height * (new_width / image.width)				)
				A__							 =       int(header_image.height * (new_width / header_image.width)				)

				A__							 =       Image.new('RGB'       ,(new_width, new_height + new_header_height)       ,'white'				)
				new_image.paste(header_image.resize((new_width, new_header_height)				)       ,(0, 0)				)
				new_image.paste(image.resize((new_width, new_height)				)       ,(0, new_header_height)				)

				# Convert back to the original framework if necessary
				A__							 =       to_numpy_array(lowerCAmelCase__				)

				if infer_channel_dimension_format(lowerCAmelCase__				) == ChannelDimension.LAST:
								A__							 =       to_channel_dimension_format(lowerCAmelCase__       ,ChannelDimension.LAST				)

				return new_image







class       snake_case_       (    _lowerCamelCase       ):



	"""simple docstring"""

	SCREAMING_SNAKE_CASE_:							Optional[int]   			=					["""flattened_patches"""]


	def __init__(      self  ,					__a = True  ,					__a = True  ,					__a = None  ,					__a = 2048  ,					__a = False  ,					**__a  ,					):


					"""simple docstring"""

					super().__init__(**__a						)
					A__							 =       patch_size if patch_size is not None else {'height': 16, 'width': 16}
					A__							 =       do_normalize
					A__							 =       do_convert_rgb
					A__							 =       max_patches
					A__							 =       is_vqa


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a  ,					__a  ,					**__a						):


					"""simple docstring"""

					requires_backends(self.extract_flattened_patches  ,					'torch'						)
					_check_torch_version()

					# convert to torch
					A__							 =       to_channel_dimension_format(__a  ,					ChannelDimension.FIRST						)
					A__							 =       torch.from_numpy(__a						)

					A__ ,			A__							 =       patch_size['height'], patch_size['width']
					A__ ,			A__							 =       get_image_size(__a						)

					# maximize scale s.t.
					A__							 =       math.sqrt(max_patches * (patch_height / image_height) * (patch_width / image_width)						)
					A__							 =       max(min(math.floor(scale * image_height / patch_height						)  ,					__a						)  ,					1						)
					A__							 =       max(min(math.floor(scale * image_width / patch_width						)  ,					__a						)  ,					1						)
					A__							 =       max(num_feasible_rows * patch_height  ,					1						)
					A__							 =       max(num_feasible_cols * patch_width  ,					1						)

					A__							 =       torch.nn.functional.interpolate(
					    image.unsqueeze(0						)  ,					size=(resized_height, resized_width)  ,					mode='bilinear'  ,					align_corners=__a  ,					antialias=__a  ,					).squeeze(0						)

					# [1, rows, columns, patch_height * patch_width * image_channels]
					A__							 =       torch_extract_patches(__a  ,					__a  ,					__a						)

					A__							 =       patches.shape
					A__							 =       patches_shape[1]
					A__							 =       patches_shape[2]
					A__							 =       patches_shape[3]

					# [rows * columns, patch_height * patch_width * image_channels]
					A__							 =       patches.reshape([rows * columns, depth]						)

					# [rows * columns, 1]
					A__							 =       torch.arange(__a						).reshape([rows, 1]						).repeat(1  ,					__a						).reshape([rows * columns, 1]						)
					A__							 =       torch.arange(__a						).reshape([1, columns]						).repeat(__a  ,					1						).reshape([rows * columns, 1]						)

					# Offset by 1 so the ids do not contain zeros, which represent padding.
					row_ids += 1
					col_ids += 1

					# Prepare additional patch features.
					# [rows * columns, 1]
					A__							 =       row_ids.to(torch.floataa						)
					A__							 =       col_ids.to(torch.floataa						)

					# [rows * columns, 2 + patch_height * patch_width * image_channels]
					A__							 =       torch.cat([row_ids, col_ids, patches]  ,					-1						)

					# [max_patches, 2 + patch_height * patch_width * image_channels]
					A__							 =       torch.nn.functional.pad(__a  ,					[0, 0, 0, max_patches - (rows * columns)]						).float()

					A__							 =       to_numpy_array(__a						)

					return result


	def       _UpperCAmelCase						(      self  ,					__a  ,					__a = None  ,					**__a						):


					"""simple docstring"""

					if image.dtype == np.uinta:
									A__							 =       image.astype(np.floataa						)

					# take mean across the whole `image`
					A__							 =       np.mean(__a						)
					A__							 =       np.std(__a						)
					A__							 =       max(__a  ,					1.0 / math.sqrt(np.prod(image.shape						)						)						)

					return normalize(__a  ,					mean=__a  ,					std=__a  ,					**__a						)






	def       _UpperCAmelCase						(      self  ,					__a  ,					__a = None  ,					__a = None  ,					__a = None  ,					__a = None  ,					__a = None  ,					__a = None  ,					__a = ChannelDimension.FIRST  ,					**__a  ,					):


					"""simple docstring"""

					A__							 =       do_normalize if do_normalize is not None else self.do_normalize
					A__							 =       do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb
					A__							 =       patch_size if patch_size is not None else self.patch_size
					A__							 =       max_patches if max_patches is not None else self.max_patches
					A__							 =       self.is_vqa

					if kwargs.get('data_format'  ,					__a						) is not None:
									raise ValueError('data_format is not an accepted input as the outputs are '						)

					A__							 =       make_list_of_images(__a						)

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

					# PIL RGBA images are converted to RGB
					if do_convert_rgb:
									A__							 =       [convert_to_rgb(__a						) for image in images]

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

					if is_vqa:
									if header_text is None:
													raise ValueError('A header text must be provided for VQA models.'						)
									A__							 =       kwargs.pop('font_bytes'  ,					__a						)
									A__							 =       kwargs.pop('font_path'  ,					__a						)

									if isinstance(__a  ,					__a						):
													A__							 =       [header_text] * len(__a						)

									A__							 =       [
									    render_header(__a  ,					header_text[i]  ,					font_bytes=__a  ,					font_path=__a						)
									    for i, image in enumerate(__a						)
									]

					if do_normalize:
									A__							 =       [self.normalize(image=__a						) for image in images]

					# convert to torch tensor and permute
					A__							 =       [
					    self.extract_flattened_patches(image=__a  ,					max_patches=__a  ,					patch_size=__a						)
					    for image in images
					]

					# create attention mask in numpy
					A__							 =       [(image.sum(axis=-1						) != 0).astype(np.floataa						) for image in images]

					A__							 =       BatchFeature(
					    data={'flattened_patches': images, 'attention_mask': attention_masks}  ,					tensor_type=__a						)

					return encoded_outputs


