




'''simple docstring'''
import argparse
import gc
import os
import sys
from pathlib import Path
from typing import List  # noqa: F401

import pytorch_lightning as pl
import torch
from finetune import SummarizationModule, TranslationModule
from finetune import main as ft_main
from make_student import create_student_by_copying_alternating_layers, get_layers_to_supervise
from torch import nn

from transformers import AutoModelForSeqaSeqLM, MBartTokenizer, TaForConditionalGeneration
from transformers.models.bart.modeling_bart import shift_tokens_right
from utils import calculate_bleu, check_output_dir, freeze_params, label_smoothed_nll_loss, use_task_specific_params


# need the parent dir module
sys.path.insert(2, str(Path(__file__).resolve().parents[1]))
from lightning_base import generic_train  # noqa






class        SCREAMING_SNAKE_CASE(				__A     ):
       snake_case_ :     str    =					["""loss""", """ce_loss""", """mlm_loss""", """hid_loss_enc""", """hid_loss_dec"""]

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

           """simple docstring"""



           assert Path(hparams.data_dir     ).exists()
           __lowercase							=						Path(hparams.output_dir     )
           self.output_dir.mkdir(exist_ok=lowerCamelCase__     )

           __lowercase							=						self.output_dir.joinpath("""student"""     )

           __lowercase							=						str(lowerCamelCase__     )  # Tell lightning we are training the student
           __lowercase							=						AutoModelForSeqaSeqLM.from_pretrained(hparams.teacher     ).eval()
           use_task_specific_params(lowerCamelCase__					,		hparams.task     )  # We copy good generation parameters to student by default
           if hparams.student is not None:
               __lowercase							=						AutoModelForSeqaSeqLM.from_pretrained(hparams.student     )
               use_task_specific_params(lowerCamelCase__					,		hparams.task     )
               __lowercase				,__lowercase							=						None, None
           else:
               __lowercase				,__lowercase				,__lowercase							=						create_student_by_copying_alternating_layers(
                   lowerCamelCase__					,		e=hparams.student_encoder_layers					,		d=hparams.student_decoder_layers					,		save_path=lowerCamelCase__     )

           if hparams.length_penalty != -1:
               __lowercase							=						hparams.length_penalty
           __lowercase							=						hparams.teacher  # Use teacher's tokenizer
           super().__init__(lowerCamelCase__					,		model=lowerCamelCase__					,		config=student.config     )
           assert student.config.model_type == teacher.config.model_type, (
               F'teacher, student model types should be the same, got {student.config.model_type} !='
               F' {teacher.config.model_type}'
           )

           if student.config.model_type == "t5":
               __lowercase							=						len(student.get_encoder().block     )
               __lowercase							=						len(student.get_decoder().block     )
               __lowercase							=						len(teacher.get_encoder().block     )
               __lowercase							=						len(teacher.get_decoder().block     )
           else:
               __lowercase							=						student.config.encoder_layers
               __lowercase							=						student.config.decoder_layers
               __lowercase							=						teacher.config.encoder_layers
               __lowercase							=						teacher.config.decoder_layers

           __lowercase							=						not (hparams.student is None or hparams.teacher == hparams.student)
           __lowercase							=						(not self.different_base_models) and hparams.alpha_hid > 0
           __lowercase							=						self.different_base_models or (student_encoder_layers != teacher_encoder_layers)
           # self.different_encoder determines whether we need to run the teacher encoder
           __lowercase							=						teacher
           freeze_params(self.teacher     )

           if not self.different_encoder:  # To save RAM, delete teacher encoder and freeze student encoder.
               try:
                   del self.teacher.model.encoder
               except AttributeError:  # T5
                   del self.teacher.encoder

           if e_layer_ids is None:
               __lowercase							=						list(range(lowerCamelCase__     )     )
           if d_layer_ids is None:
               __lowercase							=						list(range(lowerCamelCase__     )     )

           __lowercase				,__lowercase							=						e_layer_ids, d_layer_ids  # type: List[int], List[int]

           if self.do_calc_hidden_loss:  # Intermediate supervision: Decide which layers to supervise
               if hparams.supervise_forward:
                   __lowercase							=						get_layers_to_supervise(
                       n_student=len(self.e_layer_ids     )					,		n_teacher=lowerCamelCase__     )
                   __lowercase							=						get_layers_to_supervise(
                       n_student=len(self.d_layer_ids     )					,		n_teacher=lowerCamelCase__     )
               else:  # student layer should emulate hidden states of the teacher layer it was copied from
                   __lowercase							=						self.e_layer_ids
                   __lowercase							=						self.d_layer_ids
           else:
               __lowercase							=						None
               __lowercase							=						None

           __lowercase							=						nn.KLDivLoss(reduction="""batchmean"""     )
           __lowercase							=						2.0
           __lowercase							=						hparams.alpha_mlm
           __lowercase							=						hparams.alpha_ce
           __lowercase							=						hparams.alpha_hid
           gc.collect()
           torch.cuda.empty_cache()

       def     snake_case__			(    self					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )    ->					List[Any]:

           """simple docstring"""



           __lowercase							=						mask[:, :, None].expand_as(lowerCamelCase__     )
           __lowercase							=						s_logits.size(-1     )
           __lowercase							=						torch.masked_select(lowerCamelCase__					,		lowerCamelCase__     )  # (bs * seq_length * voc_size) modulo the 1s in mask
           __lowercase							=						torch.masked_select(lowerCamelCase__					,		lowerCamelCase__     )  # (bs * seq_length * voc_size) modulo the 1s in mask
           __lowercase							=						s_logits_slct.view(-1					,		lowerCamelCase__     )  # (bs * seq_length, voc_size) modulo the 1s in mask
           __lowercase							=						t_logits_slct.view(-1					,		lowerCamelCase__     )  # (bs * seq_length, voc_size) modulo the 1s in mask
           assert t_logits_slct.size() == s_logits_slct.size()
           __lowercase							=						(
               self.ce_loss_fct(
                   nn.functional.log_softmax(s_logits_slct / self.temperature					,		dim=-1     )					,		nn.functional.softmax(t_logits_slct / self.temperature					,		dim=-1     )					,		)
               * (self.temperature) ** 2
           )
           return loss_ce

       @staticmethod
       def     snake_case__			(    lowerCamelCase__					,		lowerCamelCase__     )    ->					Optional[Any]:

           """simple docstring"""



           SummarizationModule.add_model_specific_args(lowerCamelCase__					,		lowerCamelCase__     )
           add_distill_args(lowerCamelCase__     )
           return parser

       def     snake_case__			(    self					,		lowerCamelCase__     )    ->					tuple:

           """simple docstring"""



           __lowercase							=						self.tokenizer.pad_token_id
           __lowercase				,__lowercase				,__lowercase							=						batch["""input_ids"""], batch["""attention_mask"""], batch["""labels"""]
           if isinstance(self.model					,		lowerCamelCase__     ):
               __lowercase							=						self.model._shift_right(lowerCamelCase__     )
           else:
               __lowercase							=						shift_tokens_right(lowerCamelCase__					,		lowerCamelCase__     )

           # noinspection PyCallingNonCallable
           __lowercase							=						self(
               lowerCamelCase__					,		attention_mask=lowerCamelCase__					,		decoder_input_ids=lowerCamelCase__					,		output_hidden_states=self.do_calc_hidden_loss					,		output_attentions=lowerCamelCase__					,		use_cache=lowerCamelCase__					,		)
           __lowercase							=						student_outputs["""logits"""]

           # Same cross entropy vs. label smoothing logic as finetune.py
           assert lm_logits.shape[-1] == self.model.config.vocab_size
           if self.hparams.label_smoothing == 0:
               # Same behavior as modeling_bart.py, besides ignoring pad_token_id
               __lowercase							=						nn.CrossEntropyLoss(ignore_index=lowerCamelCase__     )
               __lowercase							=						loss_fct(lm_logits.view(-1					,		lm_logits.shape[-1]     )					,		labels.view(-1     )     )
           else:
               __lowercase							=						nn.functional.log_softmax(lowerCamelCase__					,		dim=-1     )
               __lowercase				,__lowercase							=						label_smoothed_nll_loss(
                   lowerCamelCase__					,		lowerCamelCase__					,		self.hparams.label_smoothing					,		ignore_index=lowerCamelCase__     )

           def zero_tensor():
               return torch.tensor(0.0     ).type_as(lowerCamelCase__     )

           __lowercase							=						student_outputs[
               """encoder_last_hidden_state"""
           ]  # use this unless self.different_base_models
           __lowercase				,__lowercase							=						zero_tensor(), zero_tensor()
           if self.different_encoder:  # compute encoder hidden state loss
               __lowercase							=						self.teacher.get_encoder()(
                   lowerCamelCase__					,		attention_mask=lowerCamelCase__					,		output_hidden_states=self.do_calc_hidden_loss					,		)
               if self.different_base_models:
                   __lowercase							=						all_teacher_encoder_outputs["""last_hidden_state"""]
               elif self.do_calc_hidden_loss:
                   __lowercase							=						self.calc_hidden_loss(
                       lowerCamelCase__					,		student_outputs["""encoder_hidden_states"""]					,		all_teacher_encoder_outputs["""hidden_states"""]					,		self.e_matches					,		normalize_hidden=self.hparams.normalize_hidden					,		)

           __lowercase							=						self.teacher(
               lowerCamelCase__					,		attention_mask=lowerCamelCase__					,		encoder_outputs=(teacher_enc_outputs,)					,		decoder_input_ids=lowerCamelCase__					,		output_hidden_states=self.do_calc_hidden_loss					,		use_cache=lowerCamelCase__					,		)
           __lowercase							=						decoder_input_ids.ne(lowerCamelCase__     )
           __lowercase							=						self.calc_ce_loss(lowerCamelCase__					,		lowerCamelCase__					,		teacher_outputs["""logits"""]     )
           if self.do_calc_hidden_loss:  # Intermediate supervision of decoder hidden states
               __lowercase							=						self.calc_hidden_loss(
                   lowerCamelCase__					,		student_outputs["""decoder_hidden_states"""]					,		teacher_outputs["""decoder_hidden_states"""]					,		self.d_matches					,		normalize_hidden=self.hparams.normalize_hidden					,		)

           __lowercase							=						(
               self.alpha_ce * loss_ce
               + self.alpha_mlm * student_lm_loss
               + self.hparams.alpha_hid * (hid_loss_enc + hid_loss_dec)
           )
           return blended_loss, loss_ce, student_lm_loss, hid_loss_enc, hid_loss_dec




       @staticmethod
       def     snake_case__			(    lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )    ->					Optional[Any]:

           """simple docstring"""



           __lowercase							=						"""expected list or tuple for hidden_states, got tensor of shape: """
           assert not isinstance(lowerCamelCase__					,		torch.Tensor     ), F'{msg}{hidden_states.shape}'
           assert not isinstance(lowerCamelCase__					,		torch.Tensor     ), F'{msg}{hidden_states_T.shape}'
           __lowercase							=						attention_mask.to(hidden_states[0]     )
           __lowercase							=						mask.sum() * hidden_states[0].size(-1     )
           __lowercase							=						torch.stack([hidden_states[i] for i in range(len(lowerCamelCase__     )     )]     )
           __lowercase							=						torch.stack([hidden_states_T[j] for j in matches]     )
           assert student_states.shape == teacher_states.shape, F'{student_states.shape} != {teacher_states.shape}'
           if normalize_hidden:
               __lowercase							=						nn.functional.layer_norm(lowerCamelCase__					,		student_states.shape[1:]     )
               __lowercase							=						nn.functional.layer_norm(lowerCamelCase__					,		teacher_states.shape[1:]     )
           __lowercase							=						nn.functional.mse_loss(lowerCamelCase__					,		lowerCamelCase__					,		reduction="""none"""     )
           __lowercase							=						(mse * mask.unsqueeze(0     ).unsqueeze(-1     )).sum() / valid_count
           return masked_mse

def 				snake_case_  (   a__		:	Any			):



    """simple docstring"""




    parser.add_argument("""--teacher"""    ,type=a__			)
    parser.add_argument("""--alpha_ce"""    ,default=0.8    ,type=a__			)
    parser.add_argument("""--alpha_mlm"""    ,default=0.2    ,type=a__			)
    parser.add_argument("""--alpha_hid"""    ,default=0.0    ,type=a__    ,required=a__			)
    parser.add_argument("""--student"""    ,type=a__    ,required=a__			)
    parser.add_argument("""--student_decoder_layers"""    ,default=12    ,type=a__    ,required=a__			)
    parser.add_argument("""--student_encoder_layers"""    ,default=12    ,type=a__    ,required=a__			)
    parser.add_argument("""--no_teacher"""    ,action="""store_true"""    ,default=a__			)
    parser.add_argument("""--length_penalty"""    ,type=a__    ,default=-1			)
    parser.add_argument("""--supervise_forward"""    ,action="""store_true"""    ,default=a__			)
    parser.add_argument("""--normalize_hidden"""    ,action="""store_true"""    ,default=a__			)






class        SCREAMING_SNAKE_CASE(				__A     ):
       snake_case_ :     Union[str, Any]    =					"""translation"""
       snake_case_ :     Tuple    =					["""bleu"""]
       snake_case_ :     Optional[Any]    =					"""bleu"""

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

           """simple docstring"""



           super().__init__(lowerCamelCase__					,		**lowerCamelCase__     )
           assert hparams.src_lang is not None
           assert hparams.tgt_lang is not None
           __lowercase							=						hparams.src_lang
           __lowercase							=						hparams.tgt_lang
           if self.model.config.decoder_start_token_id is None and isinstance(self.tokenizer					,		lowerCamelCase__     ):
               __lowercase							=						self.tokenizer.lang_code_to_id[hparams.tgt_lang]

       def     snake_case__			(    self					,		lowerCamelCase__					,		lowerCamelCase__     )    ->					dict:

           """simple docstring"""



           return calculate_bleu(lowerCamelCase__					,		lowerCamelCase__     )




       @staticmethod
       def     snake_case__			(    lowerCamelCase__					,		lowerCamelCase__     )    ->					Union[str, Any]:

           """simple docstring"""



           TranslationModule.add_model_specific_args(lowerCamelCase__					,		lowerCamelCase__     )
           add_distill_args(lowerCamelCase__     )
           return parser

def 				snake_case_  (   a__		:	List[Any]			):



    """simple docstring"""




    if args.no_teacher:
        __lowercase							=						TranslationModule if """translation""" in args.task else SummarizationModule
    else:  # DISTILL WITH TEACHER
        __lowercase							=						TranslationDistiller if """translation""" in args.task else SummarizationDistiller
    __lowercase							=						module_cls.__name__
    print(f'using module {args.setup_cls}'			)
    __lowercase							=						module_cls(a__			)
    return model
def 				snake_case_  (   a__		:	Optional[Any]			):



    """simple docstring"""




    Path(args.output_dir			).mkdir(exist_ok=a__			)
    check_output_dir(a__    ,expected_items=3			)

    __lowercase							=						create_module(a__			)
    return ft_main(a__    ,model=a__			)


if __name__ == "__main__":
  A							:      str 	=       argparse.ArgumentParser()
  A							:      Optional[int] 	=       pl.Trainer.add_argparse_args(parser)
  A							:      Union[str, Any] 	=       SummarizationDistiller.add_model_specific_args(parser, os.getcwd())
  A							:      Dict 	=       parser.parse_args()

  distill_main(args)










'''simple docstring'''
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
  import torch

if is_vision_available():
  from PIL import Image

  from transformers import BlipImageProcessor






class        SCREAMING_SNAKE_CASE(				unittest.TestCase     ):

       def __init__(    self					,		lowerCamelCase__					,		lowerCamelCase__=7					,		lowerCamelCase__=3					,		lowerCamelCase__=18					,		lowerCamelCase__=30					,		lowerCamelCase__=400					,		lowerCamelCase__=True					,		lowerCamelCase__=None					,		lowerCamelCase__=True					,		lowerCamelCase__=False					,		lowerCamelCase__=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]					,		lowerCamelCase__=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]					,		lowerCamelCase__=True					,		)    ->					Union[str, Any]:

           """simple docstring"""



           __lowercase							=						size if size is not None else {"""height""": 20, """width""": 20}
           __lowercase							=						parent
           __lowercase							=						batch_size
           __lowercase							=						num_channels
           __lowercase							=						image_size
           __lowercase							=						min_resolution
           __lowercase							=						max_resolution
           __lowercase							=						do_resize
           __lowercase							=						size
           __lowercase							=						do_normalize
           __lowercase							=						image_mean
           __lowercase							=						image_std
           __lowercase							=						do_pad
           __lowercase							=						do_convert_rgb

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

           """simple docstring"""



           return {
               "do_resize": self.do_resize,
               "size": self.size,
               "do_normalize": self.do_normalize,
               "image_mean": self.image_mean,
               "image_std": self.image_std,
               "do_convert_rgb": self.do_convert_rgb,
               "do_pad": self.do_pad,
           }




       def     snake_case__			(    self					,		lowerCamelCase__=False					,		lowerCamelCase__=False					,		lowerCamelCase__=False     )    ->					Tuple:

           """simple docstring"""



           assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

           if equal_resolution:
               __lowercase							=						[]
               for i in range(self.batch_size     ):
                   image_inputs.append(
                       np.random.randint(
                           255					,		size=(self.num_channels, self.max_resolution, self.max_resolution)					,		dtype=np.uinta     )     )
           else:
               __lowercase							=						[]
               for i in range(self.batch_size     ):
                   __lowercase				,__lowercase							=						np.random.choice(np.arange(self.min_resolution					,		self.max_resolution     )					,		2     )
                   image_inputs.append(np.random.randint(255					,		size=(self.num_channels, width, height)					,		dtype=np.uinta     )     )

           if not numpify and not torchify:
               # PIL expects the channel dimension as last dimension
               __lowercase							=						[Image.fromarray(np.moveaxis(lowerCamelCase__					,		0					,		-1     )     ) for x in image_inputs]

           if torchify:
               __lowercase							=						[torch.from_numpy(lowerCamelCase__     ) for x in image_inputs]

           return image_inputs






@require_torch
@require_vision
class        SCREAMING_SNAKE_CASE(				__A   ,      unittest.TestCase     ):
       snake_case_ :     Optional[int]    =					BlipImageProcessor if is_vision_available() else None

       def     snake_case__			(    self     )    ->					List[Any]:

           """simple docstring"""



           __lowercase							=						BlipImageProcessingTester(self     )

       @property
       def     snake_case__			(    self     )    ->					Optional[int]:

           """simple docstring"""



           return self.image_processor_tester.prepare_image_processor_dict()

       def     snake_case__			(    self     )    ->					List[Any]:

           """simple docstring"""



           __lowercase							=						self.image_processing_class(**self.image_processor_dict     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""do_resize"""     )     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""size"""     )     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""do_normalize"""     )     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""image_mean"""     )     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""image_std"""     )     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""do_convert_rgb"""     )     )

       def     snake_case__			(    self     )    ->					Any:

           """simple docstring"""



           pass

       def     snake_case__			(    self     )    ->					List[str]:

           """simple docstring"""



           __lowercase							=						self.image_processing_class(**self.image_processor_dict     )
           # create random PIL images
           __lowercase							=						self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__     )
           for image in image_inputs:
               self.assertIsInstance(lowerCamelCase__					,		Image.Image     )

           # Test not batched input
           __lowercase							=						image_processor(image_inputs[0]					,		return_tensors="""pt"""     ).pixel_values
           self.assertEqual(
               encoded_images.shape					,		(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )					,		)

           # Test batched
           __lowercase							=						image_processor(lowerCamelCase__					,		return_tensors="""pt"""     ).pixel_values
           self.assertEqual(
               encoded_images.shape					,		(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )					,		)

       def     snake_case__			(    self     )    ->					int:

           """simple docstring"""



           __lowercase							=						self.image_processing_class(**self.image_processor_dict     )
           # create random numpy tensors
           __lowercase							=						self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__					,		numpify=lowerCamelCase__     )
           for image in image_inputs:
               self.assertIsInstance(lowerCamelCase__					,		np.ndarray     )

           # Test not batched input
           __lowercase							=						image_processor(image_inputs[0]					,		return_tensors="""pt"""     ).pixel_values
           self.assertEqual(
               encoded_images.shape					,		(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )					,		)

           # Test batched
           __lowercase							=						image_processor(lowerCamelCase__					,		return_tensors="""pt"""     ).pixel_values
           self.assertEqual(
               encoded_images.shape					,		(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )					,		)




       def     snake_case__			(    self     )    ->					Any:

           """simple docstring"""



           __lowercase							=						self.image_processing_class(**self.image_processor_dict     )
           # create random PyTorch tensors
           __lowercase							=						self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__					,		torchify=lowerCamelCase__     )
           for image in image_inputs:
               self.assertIsInstance(lowerCamelCase__					,		torch.Tensor     )

           # Test not batched input
           __lowercase							=						image_processor(image_inputs[0]					,		return_tensors="""pt"""     ).pixel_values
           self.assertEqual(
               encoded_images.shape					,		(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )					,		)

           # Test batched
           __lowercase							=						image_processor(lowerCamelCase__					,		return_tensors="""pt"""     ).pixel_values
           self.assertEqual(
               encoded_images.shape					,		(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )					,		)






@require_torch
@require_vision
class        SCREAMING_SNAKE_CASE(				__A   ,      unittest.TestCase     ):
       snake_case_ :     Union[str, Any]    =					BlipImageProcessor if is_vision_available() else None

       def     snake_case__			(    self     )    ->					List[str]:

           """simple docstring"""



           __lowercase							=						BlipImageProcessingTester(self					,		num_channels=4     )
           __lowercase							=						3

       @property
       def     snake_case__			(    self     )    ->					str:

           """simple docstring"""



           return self.image_processor_tester.prepare_image_processor_dict()

       def     snake_case__			(    self     )    ->					Any:

           """simple docstring"""



           __lowercase							=						self.image_processing_class(**self.image_processor_dict     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""do_resize"""     )     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""size"""     )     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""do_normalize"""     )     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""image_mean"""     )     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""image_std"""     )     )
           self.assertTrue(hasattr(lowerCamelCase__					,		"""do_convert_rgb"""     )     )

       def     snake_case__			(    self     )    ->					Any:

           """simple docstring"""



           pass




       def     snake_case__			(    self     )    ->					Union[str, Any]:

           """simple docstring"""



           __lowercase							=						self.image_processing_class(**self.image_processor_dict     )
           # create random PIL images
           __lowercase							=						self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__     )
           for image in image_inputs:
               self.assertIsInstance(lowerCamelCase__					,		Image.Image     )

           # Test not batched input
           __lowercase							=						image_processor(image_inputs[0]					,		return_tensors="""pt"""     ).pixel_values
           self.assertEqual(
               encoded_images.shape					,		(
                   1,
                   self.expected_encoded_image_num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )					,		)

           # Test batched
           __lowercase							=						image_processor(lowerCamelCase__					,		return_tensors="""pt"""     ).pixel_values
           self.assertEqual(
               encoded_images.shape					,		(
                   self.image_processor_tester.batch_size,
                   self.expected_encoded_image_num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )					,		)




