




'''simple docstring'''



import inspect
import unittest

import torch
import torch.nn as nn

from accelerate.hooks import (
    AlignDevicesHook,
    ModelHook,
    SequentialHook,
    add_hook_to_module,
    attach_align_device_hook,
    remove_hook_from_module,
    remove_hook_from_submodules,
)
from accelerate.test_utils import require_multi_gpu





class      lowerCAmelCase (			nn.Module):


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



            '''simple docstring'''




            super().__init__()
            __snake_case            =	nn.Linear(3     ,	4	)
            __snake_case            =	nn.BatchNormad(4	)
            __snake_case            =	nn.Linear(4     ,	5	)




       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE	)   ->	Dict:



            '''simple docstring'''




            return self.lineara(self.batchnorm(self.lineara(__SCREAMING_SNAKE_CASE	)	)	)





class      lowerCAmelCase (			__lowerCAmelCase):


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	*__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE	)   ->	Union[str, Any]:



            '''simple docstring'''




            return (args[0] + 1,) + args[1:], kwargs





class      lowerCAmelCase (			__lowerCAmelCase):


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	Optional[int]:



            '''simple docstring'''




            return output + 1





class      lowerCAmelCase (			unittest.TestCase):


       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




            __snake_case            =	ModelForTest()
            __snake_case            =	ModelHook()

            add_hook_to_module(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)
            self.assertEqual(test_model._hf_hook     ,	__SCREAMING_SNAKE_CASE	)
            self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE     ,	'''_old_forward'''	)	)

            # Check adding the hook did not change the name or the signature
            self.assertEqual(test_model.forward.__name__     ,	'''forward'''	)
            self.assertListEqual(list(inspect.signature(test_model.forward	).parameters	)     ,	['''x''']	)

            remove_hook_from_module(__SCREAMING_SNAKE_CASE	)
            self.assertFalse(hasattr(__SCREAMING_SNAKE_CASE     ,	'''_hf_hook'''	)	)
            self.assertFalse(hasattr(__SCREAMING_SNAKE_CASE     ,	'''_old_forward'''	)	)


       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




            __snake_case            =	ModelForTest()
            __snake_case            =	ModelHook()

            add_hook_to_module(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)
            add_hook_to_module(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	append=__SCREAMING_SNAKE_CASE	)

            self.assertEqual(isinstance(test_model._hf_hook     ,	__SCREAMING_SNAKE_CASE	)     ,	__SCREAMING_SNAKE_CASE	)
            self.assertEqual(len(test_model._hf_hook.hooks	)     ,	2	)
            self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE     ,	'''_old_forward'''	)	)

            # Check adding the hook did not change the name or the signature
            self.assertEqual(test_model.forward.__name__     ,	'''forward'''	)
            self.assertListEqual(list(inspect.signature(test_model.forward	).parameters	)     ,	['''x''']	)

            remove_hook_from_module(__SCREAMING_SNAKE_CASE	)
            self.assertFalse(hasattr(__SCREAMING_SNAKE_CASE     ,	'''_hf_hook'''	)	)
            self.assertFalse(hasattr(__SCREAMING_SNAKE_CASE     ,	'''_old_forward'''	)	)


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



            '''simple docstring'''




            __snake_case            =	ModelForTest()
            __snake_case            =	torch.randn(2     ,	3	)
            __snake_case            =	test_model(x + 1	)
            __snake_case            =	test_model(x + 2	)

            __snake_case            =	PreForwardHook()
            add_hook_to_module(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)
            __snake_case            =	test_model(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	atol=1E-5	)	)

            # Attaching a hook to a model when it already has one replaces, does not chain
            __snake_case            =	PreForwardHook()
            add_hook_to_module(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)
            __snake_case            =	test_model(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	atol=1E-5	)	)

            # You need to use the sequential hook to chain two or more hooks
            __snake_case            =	SequentialHook(PreForwardHook()     ,	PreForwardHook()	)
            add_hook_to_module(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)

            __snake_case            =	test_model(__SCREAMING_SNAKE_CASE	)
            assert torch.allclose(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	atol=1E-5	)


       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	ModelForTest()
            __snake_case            =	torch.randn(2     ,	3	)
            __snake_case            =	test_model(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	PostForwardHook()
            add_hook_to_module(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)
            __snake_case            =	test_model(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE     ,	output + 1     ,	atol=1E-5	)	)

            # Attaching a hook to a model when it already has one replaces, does not chain
            __snake_case            =	PostForwardHook()
            add_hook_to_module(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)
            __snake_case            =	test_model(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE     ,	output + 1     ,	atol=1E-5	)	)

            # You need to use the sequential hook to chain two or more hooks
            __snake_case            =	SequentialHook(PostForwardHook()     ,	PostForwardHook()	)
            add_hook_to_module(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)

            __snake_case            =	test_model(__SCREAMING_SNAKE_CASE	)
            assert torch.allclose(__SCREAMING_SNAKE_CASE     ,	output + 2     ,	atol=1E-5	)


       def    lowerCAmelCase   ( self	)   ->	int:



            '''simple docstring'''




            __snake_case            =	ModelForTest()
            __snake_case            =	torch.randn(2     ,	3	)
            __snake_case            =	test_model(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	PostForwardHook()
            add_hook_to_module(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)
            __snake_case            =	test_model(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE     ,	output + 1	)	)
            self.assertTrue(outputa.requires_grad	)

            __snake_case            =	True
            __snake_case            =	test_model(__SCREAMING_SNAKE_CASE	)
            self.assertFalse(outputa.requires_grad	)


       @require_multi_gpu
       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	ModelForTest()
            # Everything is on CPU
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)

            # This will move each submodule on different devices
            add_hook_to_module(model.lineara     ,	AlignDevicesHook(execution_device=0	)	)
            add_hook_to_module(model.batchnorm     ,	AlignDevicesHook(execution_device=0	)	)
            add_hook_to_module(model.lineara     ,	AlignDevicesHook(execution_device=1	)	)

            self.assertEqual(model.lineara.weight.device     ,	torch.device(0	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device(0	)	)
            self.assertEqual(model.batchnorm.running_mean.device     ,	torch.device(0	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device(1	)	)

            # We can still make a forward pass. The input does not need to be on any particular device
            __snake_case            =	torch.randn(2     ,	3	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(output.device     ,	torch.device(1	)	)

            # We can add a general hook to put back output on same device as input.
            add_hook_to_module(__SCREAMING_SNAKE_CASE     ,	AlignDevicesHook(io_same_device=__SCREAMING_SNAKE_CASE	)	)
            __snake_case            =	torch.randn(2     ,	3	).to(0	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(output.device     ,	torch.device(0	)	)


       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




            __snake_case            =	ModelForTest()

            # Everything is on CPU
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)

            # This will move each submodule on different devices
            __snake_case            =	{'''execution_device''': 0 if torch.cuda.is_available() else '''cpu''', '''offload''': True}

            add_hook_to_module(model.lineara     ,	AlignDevicesHook(**__SCREAMING_SNAKE_CASE	)	)
            add_hook_to_module(model.batchnorm     ,	AlignDevicesHook(**__SCREAMING_SNAKE_CASE	)	)
            add_hook_to_module(model.lineara     ,	AlignDevicesHook(**__SCREAMING_SNAKE_CASE	)	)

            # Parameters have been offloaded, so on the meta device
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            # Buffers are not included in the offload by default, so are on the execution device
            __snake_case            =	torch.device(hook_kwargs['''execution_device''']	)
            self.assertEqual(model.batchnorm.running_mean.device     ,	__SCREAMING_SNAKE_CASE	)

            __snake_case            =	torch.randn(2     ,	3	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(output.device     ,	__SCREAMING_SNAKE_CASE	)

            # Removing hooks loads back the weights in the model.
            remove_hook_from_module(model.lineara	)
            remove_hook_from_module(model.batchnorm	)
            remove_hook_from_module(model.lineara	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)

            # Now test with buffers included in the offload
            __snake_case            =	{
                '''execution_device''': 0 if torch.cuda.is_available() else '''cpu''',
                '''offload''': True,
                '''offload_buffers''': True,
            }

            add_hook_to_module(model.lineara     ,	AlignDevicesHook(**__SCREAMING_SNAKE_CASE	)	)
            add_hook_to_module(model.batchnorm     ,	AlignDevicesHook(**__SCREAMING_SNAKE_CASE	)	)
            add_hook_to_module(model.lineara     ,	AlignDevicesHook(**__SCREAMING_SNAKE_CASE	)	)

            # Parameters have been offloaded, so on the meta device, buffers included
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.batchnorm.running_mean.device     ,	torch.device('''meta'''	)	)

            __snake_case            =	torch.randn(2     ,	3	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(output.device     ,	__SCREAMING_SNAKE_CASE	)

            # Removing hooks loads back the weights in the model.
            remove_hook_from_module(model.lineara	)
            remove_hook_from_module(model.batchnorm	)
            remove_hook_from_module(model.lineara	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)


       def    lowerCAmelCase   ( self	)   ->	str:



            '''simple docstring'''




            __snake_case            =	ModelForTest()

            # Everything is on CPU
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)

            # This will move each submodule on different devices
            __snake_case            =	0 if torch.cuda.is_available() else '''cpu'''
            attach_align_device_hook(__SCREAMING_SNAKE_CASE     ,	execution_device=__SCREAMING_SNAKE_CASE     ,	offload=__SCREAMING_SNAKE_CASE	)

            # Parameters have been offloaded, so on the meta device
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            # Buffers are not included in the offload by default, so are on the execution device
            __snake_case            =	torch.device(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(model.batchnorm.running_mean.device     ,	__SCREAMING_SNAKE_CASE	)

            __snake_case            =	torch.randn(2     ,	3	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(output.device     ,	__SCREAMING_SNAKE_CASE	)

            # Removing hooks loads back the weights in the model.
            remove_hook_from_submodules(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)

            # Now test with buffers included in the offload
            attach_align_device_hook(__SCREAMING_SNAKE_CASE     ,	execution_device=__SCREAMING_SNAKE_CASE     ,	offload=__SCREAMING_SNAKE_CASE     ,	offload_buffers=__SCREAMING_SNAKE_CASE	)

            # Parameters have been offloaded, so on the meta device, buffers included
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.batchnorm.running_mean.device     ,	torch.device('''meta'''	)	)

            __snake_case            =	torch.randn(2     ,	3	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(output.device     ,	__SCREAMING_SNAKE_CASE	)

            # Removing hooks loads back the weights in the model.
            remove_hook_from_submodules(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)




       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	ModelForTest()

            # Everything is on CPU
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)

            # This will move each submodule on different devices
            __snake_case            =	0 if torch.cuda.is_available() else '''cpu'''
            attach_align_device_hook(
                __SCREAMING_SNAKE_CASE     ,	execution_device=__SCREAMING_SNAKE_CASE     ,	offload=__SCREAMING_SNAKE_CASE     ,	weights_map=model.state_dict()	)

            # Parameters have been offloaded, so on the meta device
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            # Buffers are not included in the offload by default, so are on the execution device
            __snake_case            =	torch.device(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(model.batchnorm.running_mean.device     ,	__SCREAMING_SNAKE_CASE	)

            __snake_case            =	torch.randn(2     ,	3	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(output.device     ,	__SCREAMING_SNAKE_CASE	)

            # Removing hooks loads back the weights in the model.
            remove_hook_from_submodules(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)

            # Now test with buffers included in the offload
            attach_align_device_hook(
                __SCREAMING_SNAKE_CASE     ,	execution_device=__SCREAMING_SNAKE_CASE     ,	offload=__SCREAMING_SNAKE_CASE     ,	weights_map=model.state_dict()     ,	offload_buffers=__SCREAMING_SNAKE_CASE     ,	)

            # Parameters have been offloaded, so on the meta device, buffers included
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''meta'''	)	)
            self.assertEqual(model.batchnorm.running_mean.device     ,	torch.device('''meta'''	)	)

            __snake_case            =	torch.randn(2     ,	3	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(output.device     ,	__SCREAMING_SNAKE_CASE	)

            # Removing hooks loads back the weights in the model.
            remove_hook_from_submodules(__SCREAMING_SNAKE_CASE	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.batchnorm.weight.device     ,	torch.device('''cpu'''	)	)
            self.assertEqual(model.lineara.weight.device     ,	torch.device('''cpu'''	)	)














"""simple docstring"""
import warnings
from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType







class      UpperCamelCase_			(__A	):
	__magic_name__       =							['''image_processor''', '''tokenizer''']
	__magic_name__       =							'''FlavaImageProcessor'''
	__magic_name__       =							('''BertTokenizer''', '''BertTokenizerFast''')





	def __init__( self   :					Optional[int]      ,      lowerCAmelCase_   :					Tuple=None      ,      lowerCAmelCase_   :					List[str]=None      ,      **lowerCAmelCase_   :					Union[str, Any]		)		->     List[Any]:
				UpperCAmelCase_	:					Any     	=   None
				if "feature_extractor" in kwargs:
							warnings.warn(
							    "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
							    " instead."      ,      lowerCAmelCase_      ,      )
							UpperCAmelCase_	:					Tuple     	=   kwargs.pop("feature_extractor"		)

				UpperCAmelCase_	:					Optional[Any]     	=   image_processor if image_processor is not None else feature_extractor
				if image_processor is None:
							raise ValueError("You need to specify an `image_processor`."		)
				if tokenizer is None:
							raise ValueError("You need to specify a `tokenizer`."		)

				super().__init__(lowerCAmelCase_      ,      lowerCAmelCase_		)
				UpperCAmelCase_	:					List[str]     	=   self.image_processor





	def __call__( self   :					List[Any]      ,      lowerCAmelCase_   :					Optional[ImageInput] = None      ,      lowerCAmelCase_   :					Optional[Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]]] = None      ,      lowerCAmelCase_   :					bool = True      ,      lowerCAmelCase_   :					Union[bool, str, PaddingStrategy] = False      ,      lowerCAmelCase_   :					Union[bool, str, TruncationStrategy] = False      ,      lowerCAmelCase_   :					Optional[int] = None      ,      lowerCAmelCase_   :					int = 0      ,      lowerCAmelCase_   :					Optional[int] = None      ,      lowerCAmelCase_   :					Optional[bool] = None      ,      lowerCAmelCase_   :					Optional[bool] = None      ,      lowerCAmelCase_   :					Optional[bool] = None      ,      lowerCAmelCase_   :					Optional[bool] = None      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = True      ,      lowerCAmelCase_   :					Optional[Union[str, TensorType]] = None      ,      **lowerCAmelCase_   :					Optional[int]      ,      )		->     List[Any]:

				if text is None and images is None:
							raise ValueError("You have to specify either text or images. Both cannot be none."		)

				if text is not None:
							UpperCAmelCase_	:					Union[str, Any]     	=   self.tokenizer(
							    text=lowerCAmelCase_      ,      add_special_tokens=lowerCAmelCase_      ,      padding=lowerCAmelCase_      ,      truncation=lowerCAmelCase_      ,      max_length=lowerCAmelCase_      ,      stride=lowerCAmelCase_      ,      pad_to_multiple_of=lowerCAmelCase_      ,      return_token_type_ids=lowerCAmelCase_      ,      return_attention_mask=lowerCAmelCase_      ,      return_overflowing_tokens=lowerCAmelCase_      ,      return_special_tokens_mask=lowerCAmelCase_      ,      return_offsets_mapping=lowerCAmelCase_      ,      return_length=lowerCAmelCase_      ,      verbose=lowerCAmelCase_      ,      return_tensors=lowerCAmelCase_      ,      **lowerCAmelCase_      ,      )
				if images is not None:
							UpperCAmelCase_	:					Optional[Any]     	=   self.image_processor(
							    lowerCAmelCase_      ,      return_image_mask=lowerCAmelCase_      ,      return_codebook_pixels=lowerCAmelCase_      ,      return_tensors=lowerCAmelCase_      ,      **lowerCAmelCase_      ,      )

				if text is not None and images is not None:
							encoding.update(lowerCAmelCase_		)
							return encoding
				elif text is not None:
							return encoding
				else:
							return BatchEncoding(data=dict(**lowerCAmelCase_		)      ,      tensor_type=lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[int]      ,      *lowerCAmelCase_   :					int      ,      **lowerCAmelCase_   :					List[str]		)		->     Any:
				return self.tokenizer.batch_decode(*lowerCAmelCase_      ,      **lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[Any]      ,      *lowerCAmelCase_   :					List[str]      ,      **lowerCAmelCase_   :					Optional[int]		)		->     List[Any]:
				return self.tokenizer.decode(*lowerCAmelCase_      ,      **lowerCAmelCase_		)





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[Any]		)		->     int:
				UpperCAmelCase_	:					List[Any]     	=   self.tokenizer.model_input_names
				UpperCAmelCase_	:					Any     	=   self.image_processor.model_input_names
				return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names		)		)





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Tuple		)		->     Optional[Any]:
				warnings.warn(
				    "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."      ,      lowerCAmelCase_      ,      )
				return self.image_processor_class





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					str		)		->     int:
				warnings.warn(
				    "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."      ,      lowerCAmelCase_      ,      )
				return self.image_processor



