


import argparse
import logging
import os
from pathlib import Path
from typing import Any, Dict

import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_info

from transformers import (
    AdamW,
    AutoConfig,
    AutoModel,
    AutoModelForPreTraining,
    AutoModelForQuestionAnswering,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelWithLMHead,
    AutoTokenizer,
    PretrainedConfig,
    PreTrainedTokenizer,
)
from transformers.optimization import (
    Adafactor,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.utils.versions import require_version


lowerCAmelCase__				:   Tuple		= logging.getLogger(__name__)

require_version("pytorch_lightning>=1.0.4")

lowerCAmelCase__				:   List[str]		= {
    "base": AutoModel,
    "sequence-classification": AutoModelForSequenceClassification,
    "question-answering": AutoModelForQuestionAnswering,
    "pretraining": AutoModelForPreTraining,
    "token-classification": AutoModelForTokenClassification,
    "language-modeling": AutoModelWithLMHead,
    "summarization": AutoModelForSeqaSeqLM,
    "translation": AutoModelForSeqaSeqLM,
}


# update this and the import above to support new schedulers from transformers.optimization
lowerCAmelCase__				:   Optional[Any]		= {
    "linear": get_linear_schedule_with_warmup,
    "cosine": get_cosine_schedule_with_warmup,
    "cosine_w_restarts": get_cosine_with_hard_restarts_schedule_with_warmup,
    "polynomial": get_polynomial_decay_schedule_with_warmup,
    # '': get_constant_schedule,             # not supported for now
    # '': get_constant_schedule_with_warmup, # not supported for now
}
lowerCAmelCase__				:   Any		= sorted(arg_to_scheduler.keys())
lowerCAmelCase__				:   Union[str, Any]		= "{" + ", ".join(arg_to_scheduler_choices) + "}"







class       _lowercase			(							pl.LightningModule):


       """simple docstring"""




       def __init__(       self							:      Dict ,				__lowerCamelCase							:      Union[str, Any] ,				__lowerCamelCase							:      Optional[Any]=None ,				__lowerCamelCase							:      Union[str, Any]="base" ,				__lowerCamelCase							:      List[Any]=None ,				__lowerCamelCase							:      Optional[Any]=None ,				__lowerCamelCase							:      Any=None ,				**__lowerCamelCase							:      Optional[Any] ,				):


             '''simple docstring'''



             super().__init__()
             # TODO: move to self.save_hyperparameters()
             # self.save_hyperparameters()
             # can also expand arguments into trainer signature for easier reading

             self.save_hyperparameters(lowercase_	)
             lowerCamelCase__		:    Union[str, Any]   =  0
             lowerCamelCase__		:    Any   =  Path(self.hparams.output_dir	)
             lowerCamelCase__		:    Optional[int]   =  self.hparams.cache_dir if self.hparams.cache_dir else None
             if config is None:
                   lowerCamelCase__		:    List[Any]   =  AutoConfig.from_pretrained(
                       self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path ,				**({"num_labels": num_labels} if num_labels is not None else {}) ,				cache_dir=lowercase_ ,				**lowercase_ ,				)
             else:
                   lowerCamelCase__		:    Dict   =  config

             lowerCamelCase__		:    List[Any]   =  ("encoder_layerdrop", "decoder_layerdrop", "dropout", "attention_dropout")
             for p in extra_model_params:
                   if getattr(self.hparams ,				lowercase_ ,				lowercase_	):
                         assert hasattr(self.config ,				lowercase_	), f"model config doesn't have a `{p}` attribute"
                         setattr(self.config ,				lowercase_ ,				getattr(self.hparams ,				lowercase_	)	)

             if tokenizer is None:
                   lowerCamelCase__		:    Union[str, Any]   =  AutoTokenizer.from_pretrained(
                       self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path ,				cache_dir=lowercase_ ,				)
             else:
                   lowerCamelCase__		:    Optional[int]   =  tokenizer
             lowerCamelCase__		:    List[Any]   =  MODEL_MODES[mode]
             if model is None:
                   lowerCamelCase__		:    Any   =  self.model_type.from_pretrained(
                       self.hparams.model_name_or_path ,				from_tf=bool(".ckpt" in self.hparams.model_name_or_path	) ,				config=self.config ,				cache_dir=lowercase_ ,				)
             else:
                   lowerCamelCase__		:    Optional[Any]   =  model





       def 						lowerCAmelCase					(       self							:      str ,				*__lowerCamelCase							:      str ,				**__lowerCamelCase							:      List[Any]	):


             '''simple docstring'''



             lowerCamelCase__		:    Optional[Any]   =  self.model_type.from_pretrained(*lowercase_ ,				**lowercase_	)





       def 						lowerCAmelCase					(       self							:      Dict	):


             '''simple docstring'''



             lowerCamelCase__		:    Union[str, Any]   =  arg_to_scheduler[self.hparams.lr_scheduler]
             lowerCamelCase__		:    Dict   =  get_schedule_func(
                 self.opt ,				num_warmup_steps=self.hparams.warmup_steps ,				num_training_steps=self.total_steps()	)
             lowerCamelCase__		:    int   =  {"scheduler": scheduler, "interval": "step", "frequency": 1}
             return scheduler





       def 						lowerCAmelCase					(       self							:      List[Any]	):


             '''simple docstring'''



             lowerCamelCase__		:    List[Any]   =  self.model
             lowerCamelCase__		:    Optional[int]   =  ["bias", "LayerNorm.weight"]
             lowerCamelCase__		:    List[str]   =  [
                 {
                     "params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay	)],
                     "weight_decay": self.hparams.weight_decay,
                 },
                 {
                     "params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay	)],
                     "weight_decay": 0.0,
                 },
             ]
             if self.hparams.adafactor:
                   lowerCamelCase__		:    Union[str, Any]   =  Adafactor(
                       lowercase_ ,				lr=self.hparams.learning_rate ,				scale_parameter=lowercase_ ,				relative_step=lowercase_	)

             else:
                   lowerCamelCase__		:    List[Any]   =  AdamW(
                       lowercase_ ,				lr=self.hparams.learning_rate ,				eps=self.hparams.adam_epsilon	)
             lowerCamelCase__		:    Union[str, Any]   =  optimizer

             lowerCamelCase__		:    int   =  self.get_lr_scheduler()

             return [optimizer], [scheduler]





       def 						lowerCAmelCase					(       self							:      Any ,				__lowerCamelCase							:      List[Any] ,				__lowerCamelCase							:      List[Any]	):


             '''simple docstring'''



             return self.validation_step(lowercase_ ,				lowercase_	)





       def 						lowerCAmelCase					(       self							:      Optional[Any] ,				__lowerCamelCase							:      str	):


             '''simple docstring'''



             return self.validation_end(lowercase_	)





       def 						lowerCAmelCase					(       self							:      List[Any]	):


             '''simple docstring'''



             lowerCamelCase__		:    int   =  max(1 ,				self.hparams.gpus	)  # TODO: consider num_tpu_cores
             lowerCamelCase__		:    Tuple   =  self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
             return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs





       def 						lowerCAmelCase					(       self							:      Union[str, Any] ,				__lowerCamelCase							:      List[Any]	):


             '''simple docstring'''



             if mode == "test":
                   lowerCamelCase__		:    Union[str, Any]   =  len(self.test_dataloader().dataset	)
             else:
                   lowerCamelCase__		:    Optional[int]   =  self.get_dataloader("train" ,				self.hparams.train_batch_size ,				shuffle=lowercase_	)
                   lowerCamelCase__		:    List[Any]   =  len(self.train_dataloader().dataset	)





       def 						lowerCAmelCase					(       self							:      Tuple ,				__lowerCamelCase							:      str ,				__lowerCamelCase							:      Any ,				__lowerCamelCase							:      Tuple = False	):


             '''simple docstring'''



             raise NotImplementedError("You must implement this for your task"	)





       def 						lowerCAmelCase					(       self							:      int	):


             '''simple docstring'''



             return self.train_loader





       def 						lowerCAmelCase					(       self							:      Tuple	):


             '''simple docstring'''



             return self.get_dataloader("dev" ,				self.hparams.eval_batch_size ,				shuffle=lowercase_	)





       def 						lowerCAmelCase					(       self							:      Dict	):


             '''simple docstring'''



             return self.get_dataloader("test" ,				self.hparams.eval_batch_size ,				shuffle=lowercase_	)





       def 						lowerCAmelCase					(       self							:      Optional[int] ,				__lowerCamelCase							:      Optional[Any]	):


             '''simple docstring'''



             return os.path.join(
                 self.hparams.data_dir ,				"cached_{}_{}_{}".format(
                     lowercase_ ,				list(filter(lowercase_ ,				self.hparams.model_name_or_path.split("/"	)	)	).pop() ,				str(self.hparams.max_seq_length	) ,				) ,				)





       @pl.utilities.rank_zero_only
       def 						lowerCAmelCase					(       self							:      List[Any] ,				__lowerCamelCase							:      Union[str, Any]	):


             '''simple docstring'''



             lowerCamelCase__		:    List[Any]   =  self.output_dir.joinpath("best_tfmr"	)
             lowerCamelCase__		:    Any   =  self.step_count
             self.model.save_pretrained(lowercase_	)
             self.tokenizer.save_pretrained(lowercase_	)





       @staticmethod
       def 						lowerCAmelCase					(       __lowerCamelCase							:      Optional[Any] ,				__lowerCamelCase							:      int	):


             '''simple docstring'''



             parser.add_argument(
                 "--model_name_or_path" ,				default=lowercase_ ,				type=lowercase_ ,				required=lowercase_ ,				help="Path to pretrained model or model identifier from huggingface.co/models" ,				)
             parser.add_argument(
                 "--config_name" ,				default="" ,				type=lowercase_ ,				help="Pretrained config name or path if not the same as model_name"	)
             parser.add_argument(
                 "--tokenizer_name" ,				default=lowercase_ ,				type=lowercase_ ,				help="Pretrained tokenizer name or path if not the same as model_name" ,				)
             parser.add_argument(
                 "--cache_dir" ,				default="" ,				type=lowercase_ ,				help="Where do you want to store the pre-trained models downloaded from huggingface.co" ,				)
             parser.add_argument(
                 "--encoder_layerdrop" ,				type=lowercase_ ,				help="Encoder layer dropout probability (Optional). Goes into model.config" ,				)
             parser.add_argument(
                 "--decoder_layerdrop" ,				type=lowercase_ ,				help="Decoder layer dropout probability (Optional). Goes into model.config" ,				)
             parser.add_argument(
                 "--dropout" ,				type=lowercase_ ,				help="Dropout probability (Optional). Goes into model.config" ,				)
             parser.add_argument(
                 "--attention_dropout" ,				type=lowercase_ ,				help="Attention dropout probability (Optional). Goes into model.config" ,				)
             parser.add_argument("--learning_rate" ,				default=5E-5 ,				type=lowercase_ ,				help="The initial learning rate for Adam."	)
             parser.add_argument(
                 "--lr_scheduler" ,				default="linear" ,				choices=lowercase_ ,				metavar=lowercase_ ,				type=lowercase_ ,				help="Learning rate scheduler" ,				)
             parser.add_argument("--weight_decay" ,				default=0.0 ,				type=lowercase_ ,				help="Weight decay if we apply some."	)
             parser.add_argument("--adam_epsilon" ,				default=1E-8 ,				type=lowercase_ ,				help="Epsilon for Adam optimizer."	)
             parser.add_argument("--warmup_steps" ,				default=0 ,				type=lowercase_ ,				help="Linear warmup over warmup_steps."	)
             parser.add_argument("--num_workers" ,				default=4 ,				type=lowercase_ ,				help="kwarg passed to DataLoader"	)
             parser.add_argument("--num_train_epochs" ,				dest="max_epochs" ,				default=3 ,				type=lowercase_	)
             parser.add_argument("--train_batch_size" ,				default=32 ,				type=lowercase_	)
             parser.add_argument("--eval_batch_size" ,				default=32 ,				type=lowercase_	)
             parser.add_argument("--adafactor" ,				action="store_true"	)







class       _lowercase			(							pl.Callback):


       """simple docstring"""




       def 						lowerCAmelCase					(       self							:      Union[str, Any] ,				__lowerCamelCase							:      Tuple ,				__lowerCamelCase							:      Dict	):


             '''simple docstring'''



             lowerCamelCase__		:    Any   =  trainer.lr_schedulers[0]["scheduler"]
             lowerCamelCase__		:    List[str]   =  {f"lr_group_{i}": lr for i, lr in enumerate(lr_scheduler.get_lr()	)}
             pl_module.logger.log_metrics(lowercase_	)





       def 						lowerCAmelCase					(       self							:      Tuple ,				__lowerCamelCase							:      List[Any] ,				__lowerCamelCase							:      Union[str, Any]	):


             '''simple docstring'''



             rank_zero_info("***** Validation results *****"	)
             lowerCamelCase__		:    Any   =  trainer.callback_metrics
             # Log results
             for key in sorted(lowercase_	):
                   if key not in ["log", "progress_bar"]:
                         rank_zero_info("{} = {}\n".format(lowercase_ ,				str(metrics[key]	)	)	)





       def 						lowerCAmelCase					(       self							:      Optional[int] ,				__lowerCamelCase							:      Any ,				__lowerCamelCase							:      Optional[Any]	):


             '''simple docstring'''



             rank_zero_info("***** Test results *****"	)
             lowerCamelCase__		:    Tuple   =  trainer.callback_metrics
             # Log and save results to file
             lowerCamelCase__		:    Tuple   =  os.path.join(pl_module.hparams.output_dir ,				"test_results.txt"	)
             with open(lowercase_ ,				"w"	) as writer:
                   for key in sorted(lowercase_	):
                         if key not in ["log", "progress_bar"]:
                               rank_zero_info("{} = {}\n".format(lowercase_ ,				str(metrics[key]	)	)	)
                               writer.write("{} = {}\n".format(lowercase_ ,				str(metrics[key]	)	)	)



def 				lowercase_		(		_A      :   int   , _A      :   Any						):

      """simple docstring"""




      parser.add_argument(
          "--output_dir"   , default=_A   , type=_A   , required=_A   , help="The output directory where the model predictions and checkpoints will be written."   , )
      parser.add_argument(
          "--fp16"   , action="store_true"   , help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit"   , )

      parser.add_argument(
          "--fp16_opt_level"   , type=_A   , default="O2"   , help=(
              "For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\']."
              "See details at https://nvidia.github.io/apex/amp.html"
          )   , )
      parser.add_argument("--n_tpu_cores"   , dest="tpu_cores"   , type=_A						)
      parser.add_argument("--max_grad_norm"   , dest="gradient_clip_val"   , default=1.0   , type=_A   , help="Max gradient norm"						)
      parser.add_argument("--do_train"   , action="store_true"   , help="Whether to run training."						)
      parser.add_argument("--do_predict"   , action="store_true"   , help="Whether to run predictions on the test set."						)
      parser.add_argument(
          "--gradient_accumulation_steps"   , dest="accumulate_grad_batches"   , type=_A   , default=1   , help="Number of updates steps to accumulate before performing a backward/update pass."   , )
      parser.add_argument("--seed"   , type=_A   , default=42   , help="random seed for initialization"						)
      parser.add_argument(
          "--data_dir"   , default=_A   , type=_A   , required=_A   , help="The input data dir. Should contain the training files for the CoNLL-2003 NER task."   , )


def 				lowercase_		(		_A      :   BaseTransformer   , _A      :   argparse.Namespace   , _A      :   Optional[int]=None   , _A      :   Optional[int]=True   , _A      :   Union[str, Any]=[]   , _A      :   Any=None   , _A      :   int=None   , **_A      :   Union[str, Any]   , ):

      """simple docstring"""




      pl.seed_everything(args.seed						)

      # init model
      lowerCamelCase__		:    int   =  Path(model.hparams.output_dir						)
      odir.mkdir(exist_ok=_A						)

      # add custom checkpoints
      if checkpoint_callback is None:
            lowerCamelCase__		:    Any   =  pl.callbacks.ModelCheckpoint(
                filepath=args.output_dir   , prefix="checkpoint"   , monitor="val_loss"   , mode="min"   , save_top_k=1						)
      if early_stopping_callback:
            extra_callbacks.append(_A						)
      if logging_callback is None:
            lowerCamelCase__		:    int   =  LoggingCallback()

      lowerCamelCase__		:    Dict   =  {}

      # TODO: remove with PyTorch 1.6 since pl uses native amp
      if args.fpaa:
            lowerCamelCase__		:    Optional[int]   =  16
            lowerCamelCase__		:    Tuple   =  args.fpaa_opt_level

      if args.gpus > 1:
            lowerCamelCase__		:    Optional[Any]   =  "ddp"

      lowerCamelCase__		:    Tuple   =  args.accumulate_grad_batches
      lowerCamelCase__		:    Union[str, Any]   =  extra_train_kwargs.get("accelerator"   , _A						)
      lowerCamelCase__		:    Tuple   =  extra_train_kwargs.get("profiler"   , _A						)

      lowerCamelCase__		:    Tuple   =  pl.Trainer.from_argparse_args(
          _A   , weights_summary=_A   , callbacks=[logging_callback] + extra_callbacks   , logger=_A   , checkpoint_callback=_A   , **_A   , )

      if args.do_train:
            trainer.fit(_A						)

      return trainer






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, prepare_image_inputs


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import EfficientNetImageProcessor







class       _lowercase			(							unittest.TestCase):


       """simple docstring"""




       def __init__(       self							:      Optional[Any] ,				__lowerCamelCase							:      List[str] ,				__lowerCamelCase							:      int=13 ,				__lowerCamelCase							:      Tuple=3 ,				__lowerCamelCase							:      Optional[Any]=18 ,				__lowerCamelCase							:      List[Any]=30 ,				__lowerCamelCase							:      Union[str, Any]=400 ,				__lowerCamelCase							:      Union[str, Any]=True ,				__lowerCamelCase							:      Union[str, Any]=None ,				__lowerCamelCase							:      Optional[Any]=True ,				__lowerCamelCase							:      str=[0.5, 0.5, 0.5] ,				__lowerCamelCase							:      Dict=[0.5, 0.5, 0.5] ,				):


             '''simple docstring'''



             lowerCamelCase__		:    Dict   =  size if size is not None else {"height": 18, "width": 18}
             lowerCamelCase__		:    Dict   =  parent
             lowerCamelCase__		:    str   =  batch_size
             lowerCamelCase__		:    Tuple   =  num_channels
             lowerCamelCase__		:    Tuple   =  image_size
             lowerCamelCase__		:    Any   =  min_resolution
             lowerCamelCase__		:    Dict   =  max_resolution
             lowerCamelCase__		:    Tuple   =  do_resize
             lowerCamelCase__		:    List[str]   =  size
             lowerCamelCase__		:    Optional[Any]   =  do_normalize
             lowerCamelCase__		:    Union[str, Any]   =  image_mean
             lowerCamelCase__		:    Optional[Any]   =  image_std





       def 						lowerCAmelCase					(       self							:      Dict	):


             '''simple docstring'''



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







@require_torch
@require_vision
class       _lowercase			(							lowercase__							,  unittest.TestCase):


       """simple docstring"""




       A__ 						=      EfficientNetImageProcessor if is_vision_available() else None





       def 						lowerCAmelCase					(       self							:      Optional[Any]	):


             '''simple docstring'''



             lowerCamelCase__		:    Optional[Any]   =  EfficientNetImageProcessorTester(self	)





       @property
       def 						lowerCAmelCase					(       self							:      Union[str, Any]	):


             '''simple docstring'''



             return self.image_processor_tester.prepare_image_processor_dict()





       def 						lowerCAmelCase					(       self							:      Dict	):


             '''simple docstring'''



             lowerCamelCase__		:    Union[str, Any]   =  self.image_processing_class(**self.image_processor_dict	)
             self.assertTrue(hasattr(__lowerCamelCase ,				"image_mean"	)	)
             self.assertTrue(hasattr(__lowerCamelCase ,				"image_std"	)	)
             self.assertTrue(hasattr(__lowerCamelCase ,				"do_normalize"	)	)
             self.assertTrue(hasattr(__lowerCamelCase ,				"do_resize"	)	)
             self.assertTrue(hasattr(__lowerCamelCase ,				"size"	)	)





       def 						lowerCAmelCase					(       self							:      Any	):


             '''simple docstring'''



             lowerCamelCase__		:    Optional[Any]   =  self.image_processing_class.from_dict(self.image_processor_dict	)
             self.assertEqual(image_processor.size ,				{"height": 18, "width": 18}	)

             lowerCamelCase__		:    Optional[int]   =  self.image_processing_class.from_dict(self.image_processor_dict ,				size=42	)
             self.assertEqual(image_processor.size ,				{"height": 42, "width": 42}	)





       def 						lowerCAmelCase					(       self							:      Dict	):


             '''simple docstring'''



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

             # Test not batched input
             lowerCamelCase__		:    Union[str, Any]   =  image_processing(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
             lowerCamelCase__		:    Dict   =  image_processing(__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 						lowerCAmelCase					(       self							:      List[Any]	):


             '''simple docstring'''



             lowerCamelCase__		:    Dict   =  self.image_processing_class(**self.image_processor_dict	)
             # create random numpy tensors
             lowerCamelCase__		:    List[Any]   =  prepare_image_inputs(self.image_processor_tester ,				equal_resolution=__lowerCamelCase ,				numpify=__lowerCamelCase	)
             for image in image_inputs:
                   self.assertIsInstance(__lowerCamelCase ,				np.ndarray	)

             # Test not batched input
             lowerCamelCase__		:    List[str]   =  image_processing(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
             lowerCamelCase__		:    Union[str, Any]   =  image_processing(__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 						lowerCAmelCase					(       self							:      List[str]	):


             '''simple docstring'''



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

             # Test not batched input
             lowerCamelCase__		:    Dict   =  image_processing(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
             lowerCamelCase__		:    List[Any]   =  image_processing(__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"],
                 ) ,				)


