






"""simple docstring"""






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 							lowerCAmelCase__				(			unittest.TestCase ):






      '''simple docstring'''

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




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  int    						=		size if size is not None else {'''height''': 20, '''width''': 20}
          SCREAMING_SNAKE_CASE_      :  Dict    						=		crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		parent
          SCREAMING_SNAKE_CASE_      :  Dict    						=		batch_size
          SCREAMING_SNAKE_CASE_      :  Any    						=		num_channels
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		image_size
          SCREAMING_SNAKE_CASE_      :  Any    						=		min_resolution
          SCREAMING_SNAKE_CASE_      :  Dict    						=		max_resolution
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		do_resize
          SCREAMING_SNAKE_CASE_      :  Any    						=		size
          SCREAMING_SNAKE_CASE_      :  Any    						=		do_center_crop
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		crop_size
          SCREAMING_SNAKE_CASE_      :  int    						=		do_normalize
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		image_mean
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		image_std
          SCREAMING_SNAKE_CASE_      :  int    						=		do_reduce_labels



      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''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 					_A			() ->       List[Any]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_      :  Tuple    						=		load_dataset('''hf-internal-testing/fixtures_ade20k'''    ,				split='''test'''							)

    SCREAMING_SNAKE_CASE_      :  Tuple    						=		Image.open(dataset[0]['''file''']							)
    SCREAMING_SNAKE_CASE_      :  str    						=		Image.open(dataset[1]['''file''']							)

    return image, map



def 					_A			() ->       Union[str, Any]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_      :  Tuple    						=		load_dataset('''hf-internal-testing/fixtures_ade20k'''    ,				split='''test'''							)

    SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		Image.open(ds[0]['''file''']							)
    SCREAMING_SNAKE_CASE_      :  List[Any]    						=		Image.open(ds[1]['''file''']							)
    SCREAMING_SNAKE_CASE_      :  Any    						=		Image.open(ds[2]['''file''']							)
    SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		Image.open(ds[3]['''file''']							)

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





@require_torch
@require_vision
class 							lowerCAmelCase__				(			UpperCAmelCase__				,		unittest.TestCase ):






      '''simple docstring'''

      __UpperCamelCase	 =  BeitImageProcessor if is_vision_available() else None
      def _SCREAMING_SNAKE_CASE (						self     :  int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		BeitImageProcessingTester(self)
      @property
      def _SCREAMING_SNAKE_CASE (						self     :  int):




          '''simple docstring'''


          return self.image_processor_tester.prepare_image_processor_dict()
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  str    						=		self.image_processing_class(**self.image_processor_dict)
          self.assertTrue(hasattr(lowercase_						,	'''do_resize'''))
          self.assertTrue(hasattr(lowercase_						,	'''size'''))
          self.assertTrue(hasattr(lowercase_						,	'''do_center_crop'''))
          self.assertTrue(hasattr(lowercase_						,	'''center_crop'''))
          self.assertTrue(hasattr(lowercase_						,	'''do_normalize'''))
          self.assertTrue(hasattr(lowercase_						,	'''image_mean'''))
          self.assertTrue(hasattr(lowercase_						,	'''image_std'''))
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		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						,	lowercase_)

          SCREAMING_SNAKE_CASE_      :  Dict    						=		self.image_processing_class.from_dict(
              self.image_processor_dict						,	size=42						,	crop_size=84						,	reduce_labels=lowercase_)
          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						,	lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]):




          '''simple docstring'''


          pass
      def _SCREAMING_SNAKE_CASE (						self     :  Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		self.image_processing_class(**self.image_processor_dict)
          # create random PIL images
          SCREAMING_SNAKE_CASE_      :  Any    						=		prepare_image_inputs(self.image_processor_tester						,	equal_resolution=lowercase_)
          for image in image_inputs:
              self.assertIsInstance(lowercase_						,	Image.Image)

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

          # Test batched
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		image_processing(lowercase_						,	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 _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		self.image_processing_class(**self.image_processor_dict)
          # create random numpy tensors
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		prepare_image_inputs(self.image_processor_tester						,	equal_resolution=lowercase_						,	numpify=lowercase_)
          for image in image_inputs:
              self.assertIsInstance(lowercase_						,	np.ndarray)

          # Test not batched input
          SCREAMING_SNAKE_CASE_      :  int    						=		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
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		image_processing(lowercase_						,	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 _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		self.image_processing_class(**self.image_processor_dict)
          # create random PyTorch tensors
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		prepare_image_inputs(self.image_processor_tester						,	equal_resolution=lowercase_						,	torchify=lowercase_)
          for image in image_inputs:
              self.assertIsInstance(lowercase_						,	torch.Tensor)

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

          # Test batched
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		image_processing(lowercase_						,	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 _SCREAMING_SNAKE_CASE (						self     :  Dict):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		self.image_processing_class(**self.image_processor_dict)
          # create random PyTorch tensors
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		prepare_image_inputs(self.image_processor_tester						,	equal_resolution=lowercase_						,	torchify=lowercase_)
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		[]
          for image in image_inputs:
              self.assertIsInstance(lowercase_						,	torch.Tensor)
              maps.append(torch.zeros(image.shape[-2:]).long())

          # Test not batched input
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		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
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		image_processing(lowercase_						,	lowercase_						,	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)
          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  Any    						=		prepare_semantic_single_inputs()

          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		image_processing(lowercase_						,	lowercase_						,	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)
          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  int    						=		prepare_semantic_batch_inputs()

          SCREAMING_SNAKE_CASE_      :  Tuple    						=		image_processing(lowercase_						,	lowercase_						,	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 _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		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
          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		prepare_semantic_single_inputs()
          SCREAMING_SNAKE_CASE_      :  Any    						=		image_processing(lowercase_						,	lowercase_						,	return_tensors='''pt''')
          self.assertTrue(encoding['''labels'''].min().item() >= 0)
          self.assertTrue(encoding['''labels'''].max().item() <= 150)

          SCREAMING_SNAKE_CASE_      :  Tuple    						=		True
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		image_processing(lowercase_						,	lowercase_						,	return_tensors='''pt''')
          self.assertTrue(encoding['''labels'''].min().item() >= 0)
          self.assertTrue(encoding['''labels'''].max().item() <= 255)



"""simple docstring"""






import argparse

import torch

from transformers import FunnelBaseModel, FunnelConfig, FunnelModel, load_tf_weights_in_funnel
from transformers.utils import logging


logging.set_verbosity_info()



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase )  ->  List[Any]:
   # Initialise PyTorch model
   lowercase__:   Optional[Any]					=      FunnelConfig.from_json_file(__UpperCAmelCase )
   print(F"""Building PyTorch model from configuration: {config}""" )
   lowercase__:   List[Any]					=      FunnelBaseModel(__UpperCAmelCase ) if base_model else FunnelModel(__UpperCAmelCase )

   # Load weights from tf checkpoint
   load_tf_weights_in_funnel(__UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase )

   # Save pytorch-model
   print(F"""Save PyTorch model to {pytorch_dump_path}""" )
   torch.save(model.state_dict()       ,    __UpperCAmelCase )


if __name__ == "__main__":
       __A			   = argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
       )
       parser.add_argument(
           "--config_file",
           default=None,
           type=str,
           required=True,
           help="The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.",
       )
       parser.add_argument(
           "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
       )
       parser.add_argument(
           "--base_model", action="store_true", help="Whether you want just the base model (no decoder) or not."
       )
       __A			   = parser.parse_args()
       convert_tf_checkpoint_to_pytorch(
           args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.base_model
       )
