



import argparse
from pathlib import Path

import requests
import torch
from PIL import Image

from transformers import (
    RobertaTokenizer,
    TrOCRConfig,
    TrOCRForCausalLM,
    TrOCRProcessor,
    VisionEncoderDecoderModel,
    ViTConfig,
    ViTImageProcessor,
    ViTModel,
)
from transformers.utils import logging


logging.set_verbosity_info()
__snake_case		:Optional[int]   	=  logging.get_logger(__name__)





def   __snake_case			(    _UpperCAmelCase     ,				_UpperCAmelCase       ):
    __a		 =       []
    for i in range(encoder_config.num_hidden_layers       ):
        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
        rename_keys.append(
            (f'encoder.deit.blocks.{i}.norm1.weight', f'encoder.encoder.layer.{i}.layernorm_before.weight')       )
        rename_keys.append((f'encoder.deit.blocks.{i}.norm1.bias', f'encoder.encoder.layer.{i}.layernorm_before.bias')       )
        rename_keys.append(
            (f'encoder.deit.blocks.{i}.attn.proj.weight', f'encoder.encoder.layer.{i}.attention.output.dense.weight')       )
        rename_keys.append(
            (f'encoder.deit.blocks.{i}.attn.proj.bias', f'encoder.encoder.layer.{i}.attention.output.dense.bias')       )
        rename_keys.append(
            (f'encoder.deit.blocks.{i}.norm2.weight', f'encoder.encoder.layer.{i}.layernorm_after.weight')       )
        rename_keys.append((f'encoder.deit.blocks.{i}.norm2.bias', f'encoder.encoder.layer.{i}.layernorm_after.bias')       )
        rename_keys.append(
            (f'encoder.deit.blocks.{i}.mlp.fc1.weight', f'encoder.encoder.layer.{i}.intermediate.dense.weight')       )
        rename_keys.append(
            (f'encoder.deit.blocks.{i}.mlp.fc1.bias', f'encoder.encoder.layer.{i}.intermediate.dense.bias')       )
        rename_keys.append(
            (f'encoder.deit.blocks.{i}.mlp.fc2.weight', f'encoder.encoder.layer.{i}.output.dense.weight')       )
        rename_keys.append((f'encoder.deit.blocks.{i}.mlp.fc2.bias', f'encoder.encoder.layer.{i}.output.dense.bias')       )

    # cls token, position embeddings and patch embeddings of encoder
    rename_keys.extend(
        [
            ('''encoder.deit.cls_token''', '''encoder.embeddings.cls_token'''),
            ('''encoder.deit.pos_embed''', '''encoder.embeddings.position_embeddings'''),
            ('''encoder.deit.patch_embed.proj.weight''', '''encoder.embeddings.patch_embeddings.projection.weight'''),
            ('''encoder.deit.patch_embed.proj.bias''', '''encoder.embeddings.patch_embeddings.projection.bias'''),
            ('''encoder.deit.norm.weight''', '''encoder.layernorm.weight'''),
            ('''encoder.deit.norm.bias''', '''encoder.layernorm.bias'''),
        ]       )

    return rename_keys





def   __snake_case			(    _UpperCAmelCase     ,				_UpperCAmelCase       ):
    for i in range(encoder_config.num_hidden_layers       ):
        # queries, keys and values (only weights, no biases)
        __a		 =       state_dict.pop(f'encoder.deit.blocks.{i}.attn.qkv.weight'       )

        __a		 =       in_proj_weight[
            : encoder_config.hidden_size, :
        ]
        __a		 =       in_proj_weight[
            encoder_config.hidden_size : encoder_config.hidden_size * 2, :
        ]
        __a		 =       in_proj_weight[
            -encoder_config.hidden_size :, :
        ]





def   __snake_case			(    _UpperCAmelCase     ,				_UpperCAmelCase     ,				_UpperCAmelCase       ):
    __a		 =       dct.pop(_UpperCAmelCase       )
    __a		 =       val





def   __snake_case			(    _UpperCAmelCase       ):
    if "handwritten" in checkpoint_url:
        __a		 =       '''https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg'''  # industry
        # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-12.jpg" # have
        # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-10.jpg" # let
        # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg"  #
        # url = "https://fki.tic.heia-fr.ch/static/img/a01-122.jpg"
    elif "printed" in checkpoint_url or "stage1" in checkpoint_url:
        __a		 =       '''https://www.researchgate.net/profile/Dinh-Sang/publication/338099565/figure/fig8/AS:840413229350922@1577381536857/An-receipt-example-in-the-SROIE-2019-dataset_Q640.jpg'''
    __a		 =       Image.open(requests.get(_UpperCAmelCase     ,				stream=_UpperCAmelCase       ).raw       ).convert('''RGB'''       )
    return im





@torch.no_grad()
def   __snake_case			(    _UpperCAmelCase     ,				_UpperCAmelCase       ):
    __a		 =       ViTConfig(image_size=384     ,				qkv_bias=_UpperCAmelCase       )
    __a		 =       TrOCRConfig()

    # size of the architecture
    if "base" in checkpoint_url:
        __a		 =       768
    elif "large" in checkpoint_url:
        # use ViT-large encoder
        __a		 =       1024
        __a		 =       4096
        __a		 =       24
        __a		 =       16
        __a		 =       1024
    else:
        raise ValueError('''Should either find \'base\' or \'large\' in checkpoint URL'''       )

    # the large-printed + stage1 checkpoints uses sinusoidal position embeddings, no layernorm afterwards
    if "large-printed" in checkpoint_url or "stage1" in checkpoint_url:
        __a		 =       False
        __a		 =       '''relu'''
        __a		 =       1024
        __a		 =       True
        __a		 =       False
        __a		 =       False

    # load HuggingFace model
    __a		 =       ViTModel(_UpperCAmelCase     ,				add_pooling_layer=_UpperCAmelCase       )
    __a		 =       TrOCRForCausalLM(_UpperCAmelCase       )
    __a		 =       VisionEncoderDecoderModel(encoder=_UpperCAmelCase     ,				decoder=_UpperCAmelCase       )
    model.eval()

    # load state_dict of original model, rename some keys
    __a		 =       torch.hub.load_state_dict_from_url(_UpperCAmelCase     ,				map_location='''cpu'''     ,				check_hash=_UpperCAmelCase       )['''model''']

    __a		 =       create_rename_keys(_UpperCAmelCase     ,				_UpperCAmelCase       )
    for src, dest in rename_keys:
        rename_key(_UpperCAmelCase     ,				_UpperCAmelCase     ,				_UpperCAmelCase       )
    read_in_q_k_v(_UpperCAmelCase     ,				_UpperCAmelCase       )

    # remove parameters we don't need
    del state_dict["encoder.deit.head.weight"]
    del state_dict["encoder.deit.head.bias"]
    del state_dict["decoder.version"]

    # add prefix to decoder keys
    for key, val in state_dict.copy().items():
        __a		 =       state_dict.pop(_UpperCAmelCase       )
        if key.startswith('''decoder'''       ) and "output_projection" not in key:
            __a		 =       val
        else:
            __a		 =       val

    # load state dict
    model.load_state_dict(_UpperCAmelCase       )

    # Check outputs on an image
    __a		 =       ViTImageProcessor(size=encoder_config.image_size       )
    __a		 =       RobertaTokenizer.from_pretrained('''roberta-large'''       )
    __a		 =       TrOCRProcessor(_UpperCAmelCase     ,				_UpperCAmelCase       )

    __a		 =       processor(images=prepare_img(_UpperCAmelCase       )     ,				return_tensors='''pt'''       ).pixel_values

    # verify logits
    __a		 =       torch.tensor([[model.config.decoder.decoder_start_token_id]]       )
    __a		 =       model(pixel_values=_UpperCAmelCase     ,				decoder_input_ids=_UpperCAmelCase       )
    __a		 =       outputs.logits

    __a		 =       torch.Size([1, 1, 50265]       )
    if "trocr-base-handwritten" in checkpoint_url:
        __a		 =       torch.tensor(
            [-1.45_02, -4.66_83, -0.53_47, -2.92_91, 9.14_35, -3.05_71, 8.97_64, 1.75_60, 8.73_58, -1.53_11]       )
    elif "trocr-large-handwritten" in checkpoint_url:
        __a		 =       torch.tensor(
            [-2.64_37, -1.31_29, -2.25_96, -5.34_55, 6.35_39, 1.76_04, 5.49_91, 1.47_02, 5.61_13, 2.01_70]       )
    elif "trocr-base-printed" in checkpoint_url:
        __a		 =       torch.tensor(
            [-5.68_16, -5.83_88, 1.13_98, -6.90_34, 6.85_05, -2.43_93, 1.22_84, -1.02_32, -1.96_61, -3.92_10]       )
    elif "trocr-large-printed" in checkpoint_url:
        __a		 =       torch.tensor(
            [-6.01_62, -7.09_59, 4.41_55, -5.10_63, 7.04_68, -3.16_31, 2.64_66, -0.30_81, -0.81_06, -1.75_35]       )

    if "stage1" not in checkpoint_url:
        assert logits.shape == expected_shape, "Shape of logits not as expected"
        assert torch.allclose(logits[0, 0, :10]     ,				_UpperCAmelCase     ,				atol=1E-3       ), "First elements of logits not as expected"

    Path(_UpperCAmelCase       ).mkdir(exist_ok=_UpperCAmelCase       )
    print(f'Saving model to {pytorch_dump_folder_path}'       )
    model.save_pretrained(_UpperCAmelCase       )
    print(f'Saving processor to {pytorch_dump_folder_path}'       )
    processor.save_pretrained(_UpperCAmelCase       )


if __name__ == "__main__":
 __snake_case		:int   	=  argparse.ArgumentParser()

 parser.add_argument(
     '''--checkpoint_url''',
     default='''https://layoutlm.blob.core.windows.net/trocr/model_zoo/fairseq/trocr-base-handwritten.pt''',
     type=str,
     help='''URL to the original PyTorch checkpoint (.pth file).''',
 )
 parser.add_argument(
     '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the folder to output PyTorch model.'''
 )
 __snake_case		:Optional[int]   	=  parser.parse_args()
 convert_tr_ocr_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)










import unittest

import numpy as np
from datasets import load_dataset

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 BeitImageProcessor

class 					_A (			unittest.TestCase					):



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


           '''simple docstring'''

           __a		 =       size if size is not None else {'''height''': 20, '''width''': 20}
           __a		 =       crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
           __a		 =       parent
           __a		 =       batch_size
           __a		 =       num_channels
           __a		 =       image_size
           __a		 =       min_resolution
           __a		 =       max_resolution
           __a		 =       do_resize
           __a		 =       size
           __a		 =       do_center_crop
           __a		 =       crop_size
           __a		 =       do_normalize
           __a		 =       image_mean
           __a		 =       image_std
           __a		 =       do_reduce_labels





       def 	_lowerCamelCase    (	self							:  str):


           '''simple docstring'''

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





def   __snake_case			(    ):
    __a		 =       load_dataset('''hf-internal-testing/fixtures_ade20k'''     ,				split='''test'''       )

    __a		 =       Image.open(dataset[0]['''file''']       )
    __a		 =       Image.open(dataset[1]['''file''']       )

    return image, map





def   __snake_case			(    ):
    __a		 =       load_dataset('''hf-internal-testing/fixtures_ade20k'''     ,				split='''test'''       )

    __a		 =       Image.open(ds[0]['''file''']       )
    __a		 =       Image.open(ds[1]['''file''']       )
    __a		 =       Image.open(ds[2]['''file''']       )
    __a		 =       Image.open(ds[3]['''file''']       )

    return [imagea, imagea], [mapa, mapa]

@require_torch
@require_vision
class 					_A (			__UpperCAmelCase   ,unittest.TestCase					):
       UpperCamelCase__						:					Union[str, Any]		      =		BeitImageProcessor if is_vision_available() else None



       def 	_lowerCamelCase    (	self							:  int):


           '''simple docstring'''

           __a		 =       BeitImageProcessingTester(self)



       @property
       def 	_lowerCamelCase    (	self							:  int):


           '''simple docstring'''

           return self.image_processor_tester.prepare_image_processor_dict()



       def 	_lowerCamelCase    (	self							:  Optional[Any]):


           '''simple docstring'''

           __a		 =       self.image_processing_class(**self.image_processor_dict)
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,	'''do_resize'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,	'''size'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,	'''do_center_crop'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,	'''center_crop'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,	'''do_normalize'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,	'''image_mean'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,	'''image_std'''))



       def 	_lowerCamelCase    (	self							:  str):


           '''simple docstring'''

           __a		 =       self.image_processing_class.from_dict(self.image_processor_dict)
           self.assertEqual(image_processor.size  ,	{'''height''': 20, '''width''': 20})
           self.assertEqual(image_processor.crop_size  ,	{'''height''': 18, '''width''': 18})
           self.assertEqual(image_processor.do_reduce_labels  ,	__SCREAMING_SNAKE_CASE)

           __a		 =       self.image_processing_class.from_dict(
               self.image_processor_dict  ,	size=42  ,	crop_size=84  ,	reduce_labels=__SCREAMING_SNAKE_CASE)
           self.assertEqual(image_processor.size  ,	{'''height''': 42, '''width''': 42})
           self.assertEqual(image_processor.crop_size  ,	{'''height''': 84, '''width''': 84})
           self.assertEqual(image_processor.do_reduce_labels  ,	__SCREAMING_SNAKE_CASE)



       def 	_lowerCamelCase    (	self							:  Dict):


           '''simple docstring'''

           pass



       def 	_lowerCamelCase    (	self							:  Tuple):


           '''simple docstring'''

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

           # Test not batched input
           __a		 =       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.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)

           # Test batched
           __a		 =       image_processing(__SCREAMING_SNAKE_CASE  ,	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.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)



       def 	_lowerCamelCase    (	self							:  int):


           '''simple docstring'''

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

           # Test not batched input
           __a		 =       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.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)

           # Test batched
           __a		 =       image_processing(__SCREAMING_SNAKE_CASE  ,	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.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)



       def 	_lowerCamelCase    (	self							:  List[Any]):


           '''simple docstring'''

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

           # Test not batched input
           __a		 =       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.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)

           # Test batched
           __a		 =       image_processing(__SCREAMING_SNAKE_CASE  ,	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.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)



       def 	_lowerCamelCase    (	self							:  Dict):


           '''simple docstring'''

           __a		 =       self.image_processing_class(**self.image_processor_dict)
           # create random PyTorch tensors
           __a		 =       prepare_image_inputs(self.image_processor_tester  ,	equal_resolution=__SCREAMING_SNAKE_CASE  ,	torchify=__SCREAMING_SNAKE_CASE)
           __a		 =       []
           for image in image_inputs:
               self.assertIsInstance(__SCREAMING_SNAKE_CASE  ,	torch.Tensor)
               maps.append(torch.zeros(image.shape[-2:]).long())

           # Test not batched input
           __a		 =       image_processing(image_inputs[0]  ,	maps[0]  ,	return_tensors='''pt''')
           self.assertEqual(
               encoding['''pixel_values'''].shape  ,	(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)
           self.assertEqual(
               encoding['''labels'''].shape  ,	(
                   1,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)
           self.assertEqual(encoding['''labels'''].dtype  ,	torch.long)
           self.assertTrue(encoding['''labels'''].min().item() >= 0)
           self.assertTrue(encoding['''labels'''].max().item() <= 255)

           # Test batched
           __a		 =       image_processing(__SCREAMING_SNAKE_CASE  ,	__SCREAMING_SNAKE_CASE  ,	return_tensors='''pt''')
           self.assertEqual(
               encoding['''pixel_values'''].shape  ,	(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)
           self.assertEqual(
               encoding['''labels'''].shape  ,	(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)
           self.assertEqual(encoding['''labels'''].dtype  ,	torch.long)
           self.assertTrue(encoding['''labels'''].min().item() >= 0)
           self.assertTrue(encoding['''labels'''].max().item() <= 255)

           # Test not batched input (PIL images)
           __a ,     __a		 =       prepare_semantic_single_inputs()

           __a		 =       image_processing(__SCREAMING_SNAKE_CASE  ,	__SCREAMING_SNAKE_CASE  ,	return_tensors='''pt''')
           self.assertEqual(
               encoding['''pixel_values'''].shape  ,	(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)
           self.assertEqual(
               encoding['''labels'''].shape  ,	(
                   1,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)
           self.assertEqual(encoding['''labels'''].dtype  ,	torch.long)
           self.assertTrue(encoding['''labels'''].min().item() >= 0)
           self.assertTrue(encoding['''labels'''].max().item() <= 255)

           # Test batched input (PIL images)
           __a ,     __a		 =       prepare_semantic_batch_inputs()

           __a		 =       image_processing(__SCREAMING_SNAKE_CASE  ,	__SCREAMING_SNAKE_CASE  ,	return_tensors='''pt''')
           self.assertEqual(
               encoding['''pixel_values'''].shape  ,	(
                   2,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)
           self.assertEqual(
               encoding['''labels'''].shape  ,	(
                   2,
                   self.image_processor_tester.crop_size['''height'''],
                   self.image_processor_tester.crop_size['''width'''],
               )  ,	)
           self.assertEqual(encoding['''labels'''].dtype  ,	torch.long)
           self.assertTrue(encoding['''labels'''].min().item() >= 0)
           self.assertTrue(encoding['''labels'''].max().item() <= 255)





       def 	_lowerCamelCase    (	self							:  Dict):


           '''simple docstring'''

           __a		 =       self.image_processing_class(**self.image_processor_dict)

           # ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
           __a ,     __a		 =       prepare_semantic_single_inputs()
           __a		 =       image_processing(__SCREAMING_SNAKE_CASE  ,	__SCREAMING_SNAKE_CASE  ,	return_tensors='''pt''')
           self.assertTrue(encoding['''labels'''].min().item() >= 0)
           self.assertTrue(encoding['''labels'''].max().item() <= 150)

           __a		 =       True
           __a		 =       image_processing(__SCREAMING_SNAKE_CASE  ,	__SCREAMING_SNAKE_CASE  ,	return_tensors='''pt''')
           self.assertTrue(encoding['''labels'''].min().item() >= 0)
           self.assertTrue(encoding['''labels'''].max().item() <= 255)





