






import logging

import torch
from torch import nn
from torch.nn import CrossEntropyLoss, MSELoss

from transformers.file_utils import add_start_docstrings, add_start_docstrings_to_model_forward
from transformers.models.bert.modeling_bert import (
    BERT_INPUTS_DOCSTRING,
    BERT_START_DOCSTRING,
    BertEncoder,
    BertModel,
    BertPreTrainedModel,
)


__magic_name__:					Any							=     logging.getLogger(__name__)





class 	snake_case__ (							lowerCamelCase__				):
	def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None			)							->				Union[str, Any]:
							__magic_name__      :       str       						= self.layer[current_layer](lowercase__      ,       lowercase__      ,       head_mask[current_layer]			)

							__magic_name__      :       Optional[int]       						= layer_outputs[0]

							return hidden_states





@add_start_docstrings(
    '''The bare Bert Model transformer with PABEE outputting raw hidden-states without any specific head on top.'''						,  lowerCamelCase__						,  )
class 	snake_case__ (							lowerCamelCase__				):
	def __init__(    self      ,       lowerCAmelCase__			)							->				Optional[int]:
							super().__init__(lowercase__			)

							__magic_name__      :       Tuple       						= BertEncoderWithPabee(lowercase__			)

							self.init_weights()
							__magic_name__      :       Optional[Any]       						= 0
							__magic_name__      :       Tuple       						= 0
							__magic_name__      :       Dict       						= 0

							__magic_name__      :       Optional[int]       						= 0
	def       __magic_name__    (    self      ,       lowerCAmelCase__			)							->				Optional[Any]:
							__magic_name__      :       List[str]       						= threshold
	def       __magic_name__    (    self      ,       lowerCAmelCase__			)							->				Any:
							__magic_name__      :       Any       						= patience
	def       __magic_name__    (    self			)							->				str:
							__magic_name__      :       List[str]       						= 0
							__magic_name__      :       Dict       						= 0
	def       __magic_name__    (    self			)							->				Optional[Any]:
							__magic_name__      :       Any       						= self.inference_layers_num / self.inference_instances_num
							__magic_name__      :       Optional[int]       						= (
							    F'*** Patience = {self.patience} Avg. Inference Layers = {avg_inf_layers:.2f} Speed Up ='
							    F' {1 - avg_inf_layers / self.config.num_hidden_layers:.2f} ***'
							)
							print(lowercase__			)







	@add_start_docstrings_to_model_forward(lowercase__			)
	def       __magic_name__    (    self      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=False      ,       )							->				int:

							if input_ids is not None and inputs_embeds is not None:
													raise ValueError("""You cannot specify both input_ids and inputs_embeds at the same time"""			)
							elif input_ids is not None:
													__magic_name__      :       int       						= input_ids.size()
							elif inputs_embeds is not None:
													__magic_name__      :       int       						= inputs_embeds.size()[:-1]
							else:
													raise ValueError("""You have to specify either input_ids or inputs_embeds"""			)

							__magic_name__      :       str       						= input_ids.device if input_ids is not None else inputs_embeds.device

							if attention_mask is None:
													__magic_name__      :       Union[str, Any]       						= torch.ones(lowercase__      ,       device=lowercase__			)
							if token_type_ids is None:
													__magic_name__      :       Tuple       						= torch.zeros(lowercase__      ,       dtype=torch.long      ,       device=lowercase__			)

							# We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
							# ourselves in which case we just need to make it broadcastable to all heads.
							__magic_name__      :       List[str]       						= self.get_extended_attention_mask(lowercase__      ,       lowercase__      ,       lowercase__			)

							# If a 2D ou 3D attention mask is provided for the cross-attention
							# we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
							if self.config.is_decoder and encoder_hidden_states is not None:
													__magic_name__						,__magic_name__						,__magic_name__      :       Any       						= encoder_hidden_states.size()
													__magic_name__      :       Optional[Any]       						= (encoder_batch_size, encoder_sequence_length)
													if encoder_attention_mask is None:
																			__magic_name__      :       List[str]       						= torch.ones(lowercase__      ,       device=lowercase__			)
													__magic_name__      :       Optional[Any]       						= self.invert_attention_mask(lowercase__			)
							else:
													__magic_name__      :       int       						= None

							# Prepare head mask if needed
							# 1.0 in head_mask indicate we keep the head
							# attention_probs has shape bsz x n_heads x N x N
							# input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
							# and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
							__magic_name__      :       Optional[int]       						= self.get_head_mask(lowercase__      ,       self.config.num_hidden_layers			)

							__magic_name__      :       List[Any]       						= self.embeddings(
							    input_ids=lowercase__      ,       position_ids=lowercase__      ,       token_type_ids=lowercase__      ,       inputs_embeds=lowercase__			)
							__magic_name__      :       str       						= embedding_output

							if self.training:
													__magic_name__      :       int       						= []
													for i in range(self.config.num_hidden_layers			):
																			__magic_name__      :       str       						= self.encoder.adaptive_forward(
																			    lowercase__      ,       current_layer=lowercase__      ,       attention_mask=lowercase__      ,       head_mask=lowercase__			)

																			__magic_name__      :       Union[str, Any]       						= self.pooler(lowercase__			)
																			__magic_name__      :       int       						= output_layers[i](output_dropout(lowercase__			)			)
																			res.append(lowercase__			)
							elif self.patience == 0:  # Use all layers for inference
													__magic_name__      :       Dict       						= self.encoder(
													    lowercase__      ,       attention_mask=lowercase__      ,       head_mask=lowercase__      ,       encoder_hidden_states=lowercase__      ,       encoder_attention_mask=lowercase__      ,       )
													__magic_name__      :       Optional[int]       						= self.pooler(encoder_outputs[0]			)
													__magic_name__      :       Optional[Any]       						= [output_layers[self.config.num_hidden_layers - 1](lowercase__			)]
							else:
													__magic_name__      :       Optional[int]       						= 0
													__magic_name__      :       Tuple       						= None
													__magic_name__      :       str       						= 0
													for i in range(self.config.num_hidden_layers			):
																			calculated_layer_num += 1
																			__magic_name__      :       Tuple       						= self.encoder.adaptive_forward(
																			    lowercase__      ,       current_layer=lowercase__      ,       attention_mask=lowercase__      ,       head_mask=lowercase__			)

																			__magic_name__      :       Any       						= self.pooler(lowercase__			)
																			__magic_name__      :       Any       						= output_layers[i](lowercase__			)
																			if regression:
																									__magic_name__      :       Optional[Any]       						= logits.detach()
																									if patient_result is not None:
																															__magic_name__      :       str       						= patient_result.detach()
																									if (patient_result is not None) and torch.abs(patient_result - labels			) < self.regression_threshold:
																															patient_counter += 1
																									else:
																															__magic_name__      :       List[Any]       						= 0
																			else:
																									__magic_name__      :       Dict       						= logits.detach().argmax(dim=1			)
																									if patient_result is not None:
																															__magic_name__      :       Optional[Any]       						= patient_result.detach().argmax(dim=1			)
																									if (patient_result is not None) and torch.all(labels.eq(lowercase__			)			):
																															patient_counter += 1
																									else:
																															__magic_name__      :       Any       						= 0

																			__magic_name__      :       Optional[int]       						= logits
																			if patient_counter == self.patience:
																									break
													__magic_name__      :       Dict       						= [patient_result]
													self.inference_layers_num += calculated_layer_num
													self.inference_instances_num += 1

							return res





@add_start_docstrings(
    '''Bert Model transformer with PABEE and a sequence classification/regression head on top (a linear layer on top of\n    the pooled output) e.g. for GLUE tasks. '''						,  lowerCamelCase__						,  )
class 	snake_case__ (							lowerCamelCase__				):
	def __init__(    self      ,       lowerCAmelCase__			)							->				Optional[int]:
							super().__init__(lowercase__			)
							__magic_name__      :       List[Any]       						= config.num_labels

							__magic_name__      :       Any       						= BertModelWithPabee(lowercase__			)
							__magic_name__      :       List[Any]       						= nn.Dropout(config.hidden_dropout_prob			)
							__magic_name__      :       Optional[int]       						= nn.ModuleList(
							    [nn.Linear(config.hidden_size      ,       self.config.num_labels			) for _ in range(config.num_hidden_layers			)]			)

							self.init_weights()







	@add_start_docstrings_to_model_forward(lowercase__			)
	def       __magic_name__    (    self      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       lowerCAmelCase__=None      ,       )							->				Union[str, Any]:
							__magic_name__      :       Optional[int]       						= self.bert(
							    input_ids=lowercase__      ,       attention_mask=lowercase__      ,       token_type_ids=lowercase__      ,       position_ids=lowercase__      ,       head_mask=lowercase__      ,       inputs_embeds=lowercase__      ,       output_dropout=self.dropout      ,       output_layers=self.classifiers      ,       regression=self.num_labels == 1      ,       )

							__magic_name__      :       str       						= (logits[-1],)

							if labels is not None:
													__magic_name__      :       Tuple       						= None
													__magic_name__      :       Dict       						= 0
													for ix, logits_item in enumerate(lowercase__			):
																			if self.num_labels == 1:
																									#  We are doing regression
																									__magic_name__      :       Any       						= MSELoss()
																									__magic_name__      :       Union[str, Any]       						= loss_fct(logits_item.view(-1			)      ,       labels.view(-1			)			)
																			else:
																									__magic_name__      :       List[str]       						= CrossEntropyLoss()
																									__magic_name__      :       List[str]       						= loss_fct(logits_item.view(-1      ,       self.num_labels			)      ,       labels.view(-1			)			)
																			if total_loss is None:
																									__magic_name__      :       str       						= loss
																			else:
																									total_loss += loss * (ix + 1)
																			total_weights += ix + 1
													__magic_name__      :       Optional[int]       						= (total_loss / total_weights,) + outputs

							return outputs








import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
		from PIL import Image

		from transformers import OwlViTImageProcessor, OwlViTProcessor





@require_vision
class 	snake_case__ (							unittest.TestCase				):
	def       __magic_name__    (    self			)							->				int:
							__magic_name__      :       List[str]       						= tempfile.mkdtemp()

							# fmt: off
							__magic_name__      :       Union[str, Any]       						= ["""""", """l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """lo""", """l</w>""", """w</w>""", """r</w>""", """t</w>""", """low</w>""", """er</w>""", """lowest</w>""", """newer</w>""", """wider""", """<unk>""", """<|startoftext|>""", """<|endoftext|>"""]
							# fmt: on
							__magic_name__      :       Any       						= dict(zip(lowerCAmelCase__      ,       range(len(lowerCAmelCase__			)			)			)			)
							__magic_name__      :       int       						= ["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>""", """"""]
							__magic_name__      :       Any       						= {"""unk_token""": """<unk>"""}

							__magic_name__      :       Optional[Any]       						= os.path.join(self.tmpdirname      ,       VOCAB_FILES_NAMES["""vocab_file"""]			)
							__magic_name__      :       Optional[int]       						= os.path.join(self.tmpdirname      ,       VOCAB_FILES_NAMES["""merges_file"""]			)
							with open(self.vocab_file      ,       """w"""      ,       encoding="""utf-8"""			) as fp:
													fp.write(json.dumps(lowerCAmelCase__			) + """\n"""			)
							with open(self.merges_file      ,       """w"""      ,       encoding="""utf-8"""			) as fp:
													fp.write("""\n""".join(lowerCAmelCase__			)			)

							__magic_name__      :       int       						= {
							    """do_resize""": True,
							    """size""": 20,
							    """do_center_crop""": True,
							    """crop_size""": 18,
							    """do_normalize""": True,
							    """image_mean""": [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
							    """image_std""": [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
							}
							__magic_name__      :       List[str]       						= os.path.join(self.tmpdirname      ,       lowerCAmelCase__			)
							with open(self.image_processor_file      ,       """w"""      ,       encoding="""utf-8"""			) as fp:
													json.dump(lowerCAmelCase__      ,       lowerCAmelCase__			)
	def       __magic_name__    (    self      ,       **lowerCAmelCase__			)							->				List[str]:
							return CLIPTokenizer.from_pretrained(self.tmpdirname      ,       pad_token="""!"""      ,       **lowerCAmelCase__			)
	def       __magic_name__    (    self      ,       **lowerCAmelCase__			)							->				Any:
							return CLIPTokenizerFast.from_pretrained(self.tmpdirname      ,       pad_token="""!"""      ,       **lowerCAmelCase__			)
	def       __magic_name__    (    self      ,       **lowerCAmelCase__			)							->				Optional[Any]:
							return OwlViTImageProcessor.from_pretrained(self.tmpdirname      ,       **lowerCAmelCase__			)
	def       __magic_name__    (    self			)							->				int:
							shutil.rmtree(self.tmpdirname			)
	def       __magic_name__    (    self			)							->				int:
							__magic_name__      :       str       						= [np.random.randint(2_55      ,       size=(3, 30, 4_00)      ,       dtype=np.uinta			)]

							__magic_name__      :       Any       						= [Image.fromarray(np.moveaxis(lowerCAmelCase__      ,       0      ,       -1			)			) for x in image_inputs]

							return image_inputs
	def       __magic_name__    (    self			)							->				Union[str, Any]:
							__magic_name__      :       Any       						= self.get_tokenizer()
							__magic_name__      :       str       						= self.get_rust_tokenizer()
							__magic_name__      :       Tuple       						= self.get_image_processor()

							__magic_name__      :       List[str]       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)
							processor_slow.save_pretrained(self.tmpdirname			)
							__magic_name__      :       Optional[int]       						= OwlViTProcessor.from_pretrained(self.tmpdirname      ,       use_fast=lowerCAmelCase__			)

							__magic_name__      :       int       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)
							processor_fast.save_pretrained(self.tmpdirname			)
							__magic_name__      :       List[Any]       						= OwlViTProcessor.from_pretrained(self.tmpdirname			)

							self.assertEqual(processor_slow.tokenizer.get_vocab()      ,       tokenizer_slow.get_vocab()			)
							self.assertEqual(processor_fast.tokenizer.get_vocab()      ,       tokenizer_fast.get_vocab()			)
							self.assertEqual(tokenizer_slow.get_vocab()      ,       tokenizer_fast.get_vocab()			)
							self.assertIsInstance(processor_slow.tokenizer      ,       lowerCAmelCase__			)
							self.assertIsInstance(processor_fast.tokenizer      ,       lowerCAmelCase__			)

							self.assertEqual(processor_slow.image_processor.to_json_string()      ,       image_processor.to_json_string()			)
							self.assertEqual(processor_fast.image_processor.to_json_string()      ,       image_processor.to_json_string()			)
							self.assertIsInstance(processor_slow.image_processor      ,       lowerCAmelCase__			)
							self.assertIsInstance(processor_fast.image_processor      ,       lowerCAmelCase__			)
	def       __magic_name__    (    self			)							->				Optional[int]:
							__magic_name__      :       Optional[Any]       						= OwlViTProcessor(tokenizer=self.get_tokenizer()      ,       image_processor=self.get_image_processor()			)
							processor.save_pretrained(self.tmpdirname			)

							__magic_name__      :       str       						= self.get_tokenizer(bos_token="""(BOS)"""      ,       eos_token="""(EOS)"""			)
							__magic_name__      :       Any       						= self.get_image_processor(do_normalize=lowerCAmelCase__			)

							__magic_name__      :       Tuple       						= OwlViTProcessor.from_pretrained(
							    self.tmpdirname      ,       bos_token="""(BOS)"""      ,       eos_token="""(EOS)"""      ,       do_normalize=lowerCAmelCase__			)

							self.assertEqual(processor.tokenizer.get_vocab()      ,       tokenizer_add_kwargs.get_vocab()			)
							self.assertIsInstance(processor.tokenizer      ,       lowerCAmelCase__			)

							self.assertEqual(processor.image_processor.to_json_string()      ,       image_processor_add_kwargs.to_json_string()			)
							self.assertIsInstance(processor.image_processor      ,       lowerCAmelCase__			)
	def       __magic_name__    (    self			)							->				Dict:
							__magic_name__      :       int       						= self.get_image_processor()
							__magic_name__      :       int       						= self.get_tokenizer()

							__magic_name__      :       Union[str, Any]       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)

							__magic_name__      :       Dict       						= self.prepare_image_inputs()

							__magic_name__      :       Any       						= image_processor(lowerCAmelCase__      ,       return_tensors="""np"""			)
							__magic_name__      :       str       						= processor(images=lowerCAmelCase__      ,       return_tensors="""np"""			)

							for key in input_image_proc.keys():
													self.assertAlmostEqual(input_image_proc[key].sum()      ,       input_processor[key].sum()      ,       delta=1e-2			)
	def       __magic_name__    (    self			)							->				Tuple:
							__magic_name__      :       Union[str, Any]       						= self.get_image_processor()
							__magic_name__      :       int       						= self.get_tokenizer()

							__magic_name__      :       int       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)

							__magic_name__      :       Optional[int]       						= """lower newer"""

							__magic_name__      :       Tuple       						= processor(text=lowerCAmelCase__      ,       return_tensors="""np"""			)

							__magic_name__      :       Optional[int]       						= tokenizer(lowerCAmelCase__      ,       return_tensors="""np"""			)

							for key in encoded_tok.keys():
													self.assertListEqual(encoded_tok[key][0].tolist()      ,       encoded_processor[key][0].tolist()			)
	def       __magic_name__    (    self			)							->				Tuple:
							__magic_name__      :       Tuple       						= self.get_image_processor()
							__magic_name__      :       Union[str, Any]       						= self.get_tokenizer()

							__magic_name__      :       List[str]       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)

							__magic_name__      :       Any       						= """lower newer"""
							__magic_name__      :       Union[str, Any]       						= self.prepare_image_inputs()

							__magic_name__      :       int       						= processor(text=lowerCAmelCase__      ,       images=lowerCAmelCase__			)

							self.assertListEqual(list(inputs.keys()			)      ,       ["""input_ids""", """attention_mask""", """pixel_values"""]			)

							# test if it raises when no input is passed
							with pytest.raises(lowerCAmelCase__			):
													processor()
	def       __magic_name__    (    self			)							->				Optional[Any]:
							__magic_name__      :       Dict       						= """google/owlvit-base-patch32"""
							__magic_name__      :       int       						= OwlViTProcessor.from_pretrained(lowerCAmelCase__			)

							__magic_name__      :       List[Any]       						= ["""cat""", """nasa badge"""]
							__magic_name__      :       Any       						= processor(text=lowerCAmelCase__			)

							__magic_name__      :       Dict       						= 16
							self.assertListEqual(list(inputs.keys()			)      ,       ["""input_ids""", """attention_mask"""]			)
							self.assertEqual(inputs["""input_ids"""].shape      ,       (2, seq_length)			)

							# test if it raises when no input is passed
							with pytest.raises(lowerCAmelCase__			):
													processor()
	def       __magic_name__    (    self			)							->				List[Any]:
							__magic_name__      :       List[str]       						= """google/owlvit-base-patch32"""
							__magic_name__      :       Optional[Any]       						= OwlViTProcessor.from_pretrained(lowerCAmelCase__			)

							__magic_name__      :       Tuple       						= [["""cat""", """nasa badge"""], ["""person"""]]
							__magic_name__      :       Tuple       						= processor(text=lowerCAmelCase__			)

							__magic_name__      :       str       						= 16
							__magic_name__      :       str       						= len(lowerCAmelCase__			)
							__magic_name__      :       int       						= max([len(lowerCAmelCase__			) for texts in input_texts]			)

							self.assertListEqual(list(inputs.keys()			)      ,       ["""input_ids""", """attention_mask"""]			)
							self.assertEqual(inputs["""input_ids"""].shape      ,       (batch_size * num_max_text_queries, seq_length)			)

							# test if it raises when no input is passed
							with pytest.raises(lowerCAmelCase__			):
													processor()
	def       __magic_name__    (    self			)							->				Any:
							__magic_name__      :       Optional[int]       						= """google/owlvit-base-patch32"""
							__magic_name__      :       Any       						= OwlViTProcessor.from_pretrained(lowerCAmelCase__			)

							__magic_name__      :       str       						= ["""cat""", """nasa badge"""]
							__magic_name__      :       List[str]       						= processor(text=lowerCAmelCase__			)

							__magic_name__      :       List[Any]       						= 16
							__magic_name__      :       Any       						= inputs["""input_ids"""]
							__magic_name__      :       Optional[Any]       						= [
							    [4_94_06, 23_68, 4_94_07, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
							    [4_94_06, 68_41, 1_13_01, 4_94_07, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
							]

							self.assertListEqual(list(inputs.keys()			)      ,       ["""input_ids""", """attention_mask"""]			)
							self.assertEqual(inputs["""input_ids"""].shape      ,       (2, seq_length)			)
							self.assertListEqual(list(input_ids[0]			)      ,       predicted_ids[0]			)
							self.assertListEqual(list(input_ids[1]			)      ,       predicted_ids[1]			)
	def       __magic_name__    (    self			)							->				Tuple:
							__magic_name__      :       List[str]       						= self.get_image_processor()
							__magic_name__      :       Dict       						= self.get_tokenizer()

							__magic_name__      :       Tuple       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)

							__magic_name__      :       Tuple       						= self.prepare_image_inputs()
							__magic_name__      :       List[Any]       						= self.prepare_image_inputs()

							__magic_name__      :       List[str]       						= processor(images=lowerCAmelCase__      ,       query_images=lowerCAmelCase__			)

							self.assertListEqual(list(inputs.keys()			)      ,       ["""query_pixel_values""", """pixel_values"""]			)

							# test if it raises when no input is passed
							with pytest.raises(lowerCAmelCase__			):
													processor()







	def       __magic_name__    (    self			)							->				Any:
							__magic_name__      :       Optional[Any]       						= self.get_image_processor()
							__magic_name__      :       List[Any]       						= self.get_tokenizer()

							__magic_name__      :       Tuple       						= OwlViTProcessor(tokenizer=lowerCAmelCase__      ,       image_processor=lowerCAmelCase__			)

							__magic_name__      :       Union[str, Any]       						= [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

							__magic_name__      :       Optional[Any]       						= processor.batch_decode(lowerCAmelCase__			)
							__magic_name__      :       Optional[int]       						= tokenizer.batch_decode(lowerCAmelCase__			)

							self.assertListEqual(lowerCAmelCase__      ,       lowerCAmelCase__			)
