





'''simple docstring'''

import random
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():
			import PIL

			from transformers import FlavaImageProcessor
			from transformers.image_utils import PILImageResampling
			from transformers.models.flava.image_processing_flava import (
			    FLAVA_CODEBOOK_MEAN,
			    FLAVA_CODEBOOK_STD,
			    FLAVA_IMAGE_MEAN,
			    FLAVA_IMAGE_STD,
			)
else:
			lowerCAmelCase__      :   List[str]      	=			None


class      SCREAMING_SNAKE_CASE__      (   unittest.TestCase		):







					"""simple docstring"""






					def __init__(   self       :      Dict		,	UpperCAmelCase_       :      List[Any]		,	UpperCAmelCase_       :      Tuple=7		,	UpperCAmelCase_       :      Dict=3		,	UpperCAmelCase_       :      List[Any]=30		,	UpperCAmelCase_       :      List[Any]=400		,	UpperCAmelCase_       :      Optional[Any]=True		,	UpperCAmelCase_       :      Optional[int]=None		,	UpperCAmelCase_       :      Any=True		,	UpperCAmelCase_       :      Union[str, Any]=None		,	UpperCAmelCase_       :      Union[str, Any]=None		,	UpperCAmelCase_       :      List[Any]=True		,	UpperCAmelCase_       :      Union[str, Any]=1 / 255		,	UpperCAmelCase_       :      Optional[Any]=True		,	UpperCAmelCase_       :      int=FLAVA_IMAGE_MEAN		,	UpperCAmelCase_       :      int=FLAVA_IMAGE_STD		,	UpperCAmelCase_       :      Tuple=14		,	UpperCAmelCase_       :      str=75		,	UpperCAmelCase_       :      str=None		,	UpperCAmelCase_       :      int=16		,	UpperCAmelCase_       :      List[str]=0.3		,	UpperCAmelCase_       :      Optional[Any]=None		,	UpperCAmelCase_       :      int=True		,	UpperCAmelCase_       :      int=None		,	UpperCAmelCase_       :      Optional[int]=None		,	UpperCAmelCase_       :      Optional[Any]=True		,	UpperCAmelCase_       :      List[Any]=None		,	UpperCAmelCase_       :      str=True		,	UpperCAmelCase_       :      int=True		,	UpperCAmelCase_       :      str=FLAVA_CODEBOOK_MEAN		,	UpperCAmelCase_       :      str=FLAVA_CODEBOOK_STD		,	):







							"""simple docstring"""
							__UpperCAmelCase	:							int     =     size if size is not None else {"height": 224, "width": 224}
							__UpperCAmelCase	:							Any     =     crop_size if crop_size is not None else {"height": 224, "width": 224}
							__UpperCAmelCase	:							Optional[Any]     =     codebook_size if codebook_size is not None else {"height": 112, "width": 112}
							__UpperCAmelCase	:							Union[str, Any]     =     codebook_crop_size if codebook_crop_size is not None else {"height": 112, "width": 112}

							__UpperCAmelCase	:							str     =     parent
							__UpperCAmelCase	:							Tuple     =     batch_size
							__UpperCAmelCase	:							List[Any]     =     num_channels
							__UpperCAmelCase	:							Optional[Any]     =     do_resize
							__UpperCAmelCase	:							Dict     =     do_rescale
							__UpperCAmelCase	:							Dict     =     rescale_factor
							__UpperCAmelCase	:							Dict     =     min_resolution
							__UpperCAmelCase	:							Union[str, Any]     =     max_resolution
							__UpperCAmelCase	:							Union[str, Any]     =     size
							__UpperCAmelCase	:							List[Any]     =     resample if resample is not None else PILImageResampling.BICUBIC
							__UpperCAmelCase	:							str     =     do_normalize
							__UpperCAmelCase	:							Any     =     image_mean
							__UpperCAmelCase	:							Optional[int]     =     image_std
							__UpperCAmelCase	:							List[str]     =     do_center_crop
							__UpperCAmelCase	:							Dict     =     crop_size

							__UpperCAmelCase	:							str     =     input_size_patches
							__UpperCAmelCase	:							Optional[int]     =     total_mask_patches
							__UpperCAmelCase	:							List[Any]     =     mask_group_max_patches
							__UpperCAmelCase	:							Optional[int]     =     mask_group_min_patches
							__UpperCAmelCase	:							Any     =     mask_group_min_aspect_ratio
							__UpperCAmelCase	:							int     =     mask_group_max_aspect_ratio

							__UpperCAmelCase	:							int     =     codebook_do_resize
							__UpperCAmelCase	:							Any     =     codebook_size
							__UpperCAmelCase	:							Dict     =     codebook_resample if codebook_resample is not None else PILImageResampling.LANCZOS
							__UpperCAmelCase	:							int     =     codebook_do_center_crop
							__UpperCAmelCase	:							Dict     =     codebook_crop_size
							__UpperCAmelCase	:							int     =     codebook_do_map_pixels
							__UpperCAmelCase	:							Optional[int]     =     codebook_do_normalize
							__UpperCAmelCase	:							Any     =     codebook_image_mean
							__UpperCAmelCase	:							int     =     codebook_image_std
					def 		lowerCamelCase_   (   self       :      str		):







							"""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,
							    "resample": self.resample,
							    "do_rescale": self.do_rescale,
							    "rescale_factor": self.rescale_factor,
							    "do_center_crop": self.do_center_crop,
							    "crop_size": self.crop_size,
							    "input_size_patches": self.input_size_patches,
							    "total_mask_patches": self.total_mask_patches,
							    "mask_group_max_patches": self.mask_group_max_patches,
							    "mask_group_min_patches": self.mask_group_min_patches,
							    "mask_group_min_aspect_ratio": self.mask_group_min_aspect_ratio,
							    "mask_group_max_aspect_ratio": self.mask_group_min_aspect_ratio,
							    "codebook_do_resize": self.codebook_do_resize,
							    "codebook_size": self.codebook_size,
							    "codebook_resample": self.codebook_resample,
							    "codebook_do_center_crop": self.codebook_do_center_crop,
							    "codebook_crop_size": self.codebook_crop_size,
							    "codebook_do_map_pixels": self.codebook_do_map_pixels,
							    "codebook_do_normalize": self.codebook_do_normalize,
							    "codebook_image_mean": self.codebook_image_mean,
							    "codebook_image_std": self.codebook_image_std,
							}
					def 		lowerCamelCase_   (   self       :      Dict		):







							"""simple docstring"""
							return (self.size["height"], self.size["width"])
					def 		lowerCamelCase_   (   self       :      int		):







							"""simple docstring"""
							return (
							    (self.input_size_patches, self.input_size_patches)
							    if not isinstance(self.input_size_patches		,	UpperCAmelCase_		)
							    else self.input_size_patches
							)






					def 		lowerCamelCase_   (   self       :      str		):







							"""simple docstring"""
							return (self.codebook_size["height"], self.codebook_size["width"])






@require_torch
@require_vision
class      SCREAMING_SNAKE_CASE__      (   snake_case__							,unittest.TestCase		):







					"""simple docstring"""






					SCREAMING_SNAKE_CASE							=	FlavaImageProcessor if is_vision_available() else None
					SCREAMING_SNAKE_CASE							=	None
					def 		lowerCamelCase_   (   self       :      Dict		):







							"""simple docstring"""
							__UpperCAmelCase	:							int     =     FlavaImageProcessingTester(self		)
					@property
					def 		lowerCamelCase_   (   self       :      Dict		):







							"""simple docstring"""
							return self.image_processor_tester.prepare_image_processor_dict()
					def 		lowerCamelCase_   (   self       :      Optional[int]		):







							"""simple docstring"""
							__UpperCAmelCase	:							Union[str, Any]     =     self.image_processing_class(**self.image_processor_dict		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"image_mean"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"image_std"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"do_normalize"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"do_resize"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"resample"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"crop_size"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"do_center_crop"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"do_rescale"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"rescale_factor"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"masking_generator"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"codebook_do_resize"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"codebook_size"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"codebook_resample"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"codebook_do_center_crop"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"codebook_crop_size"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"codebook_do_map_pixels"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"codebook_do_normalize"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"codebook_image_mean"		)		)
							self.assertTrue(hasattr(UpperCAmelCase_		,	"codebook_image_std"		)		)
					def 		lowerCamelCase_   (   self       :      Union[str, Any]		):







							"""simple docstring"""
							__UpperCAmelCase	:							Tuple     =     self.image_processing_class.from_dict(self.image_processor_dict		)
							self.assertEqual(image_processor.size		,	{"height": 224, "width": 224}		)
							self.assertEqual(image_processor.crop_size		,	{"height": 224, "width": 224}		)
							self.assertEqual(image_processor.codebook_size		,	{"height": 112, "width": 112}		)
							self.assertEqual(image_processor.codebook_crop_size		,	{"height": 112, "width": 112}		)

							__UpperCAmelCase	:							Union[str, Any]     =     self.image_processing_class.from_dict(
							    self.image_processor_dict		,	size=42		,	crop_size=84		,	codebook_size=33		,	codebook_crop_size=66		)
							self.assertEqual(image_processor.size		,	{"height": 42, "width": 42}		)
							self.assertEqual(image_processor.crop_size		,	{"height": 84, "width": 84}		)
							self.assertEqual(image_processor.codebook_size		,	{"height": 33, "width": 33}		)
							self.assertEqual(image_processor.codebook_crop_size		,	{"height": 66, "width": 66}		)
					def 		lowerCamelCase_   (   self       :      Optional[Any]		):







							"""simple docstring"""
							pass
					def 		lowerCamelCase_   (   self       :      Optional[Any]		):







							"""simple docstring"""
							# Initialize image_processing
							__UpperCAmelCase	:							Tuple     =     self.image_processing_class(**self.image_processor_dict		)
							# create random PIL images
							__UpperCAmelCase	:							List[Any]     =     prepare_image_inputs(self.image_processor_tester		,	equal_resolution=UpperCAmelCase_		)
							for image in image_inputs:
									self.assertIsInstance(UpperCAmelCase_		,	PIL.Image.Image		)

							# Test not batched input
							__UpperCAmelCase	:							str     =     image_processing(image_inputs[0]		,	return_tensors="pt"		)

							# Test no bool masked pos
							self.assertFalse("bool_masked_pos" in encoded_images		)

							__UpperCAmelCase  ,			__UpperCAmelCase	:							Optional[Any]     =     self.image_processor_tester.get_expected_image_size()

							self.assertEqual(
							    encoded_images.pixel_values.shape		,	(1, self.image_processor_tester.num_channels, expected_height, expected_width)		,	)

							# Test batched
							__UpperCAmelCase	:							Any     =     image_processing(UpperCAmelCase_		,	return_tensors="pt"		)
							__UpperCAmelCase  ,			__UpperCAmelCase	:							Any     =     self.image_processor_tester.get_expected_image_size()

							# Test no bool masked pos
							self.assertFalse("bool_masked_pos" in encoded_images		)

							self.assertEqual(
							    encoded_images.pixel_values.shape		,	(
							        self.image_processor_tester.batch_size,
							        self.image_processor_tester.num_channels,
							        expected_height,
							        expected_width,
							    )		,	)
					def 		lowerCamelCase_   (   self       :      Any		,	UpperCAmelCase_       :      List[str]		,	UpperCAmelCase_       :      Tuple		):







							"""simple docstring"""
							# Initialize image_processing
							__UpperCAmelCase	:							Dict     =     self.image_processing_class(**self.image_processor_dict		)
							# create random tensors
							__UpperCAmelCase	:							str     =     prepare_image_inputs(self.image_processor_tester		,	equal_resolution=UpperCAmelCase_		,	**UpperCAmelCase_		)
							for image in image_inputs:
									self.assertIsInstance(UpperCAmelCase_		,	UpperCAmelCase_		)

							# Test not batched input
							__UpperCAmelCase	:							Union[str, Any]     =     image_processing(image_inputs[0]		,	return_tensors="pt"		)

							__UpperCAmelCase  ,			__UpperCAmelCase	:							Union[str, Any]     =     self.image_processor_tester.get_expected_image_size()
							self.assertEqual(
							    encoded_images.pixel_values.shape		,	(1, self.image_processor_tester.num_channels, expected_height, expected_width)		,	)

							__UpperCAmelCase	:							int     =     image_processing(UpperCAmelCase_		,	return_image_mask=UpperCAmelCase_		,	return_tensors="pt"		)

							__UpperCAmelCase  ,			__UpperCAmelCase	:							Optional[int]     =     self.image_processor_tester.get_expected_image_size()
							self.assertEqual(
							    encoded_images.pixel_values.shape		,	(
							        self.image_processor_tester.batch_size,
							        self.image_processor_tester.num_channels,
							        expected_height,
							        expected_width,
							    )		,	)

							__UpperCAmelCase  ,			__UpperCAmelCase	:							Tuple     =     self.image_processor_tester.get_expected_mask_size()
							self.assertEqual(
							    encoded_images.bool_masked_pos.shape		,	(
							        self.image_processor_tester.batch_size,
							        expected_height,
							        expected_width,
							    )		,	)

							# Test batched
							__UpperCAmelCase	:							Any     =     image_processing(UpperCAmelCase_		,	return_tensors="pt"		).pixel_values

							__UpperCAmelCase  ,			__UpperCAmelCase	:							Optional[Any]     =     self.image_processor_tester.get_expected_image_size()
							self.assertEqual(
							    encoded_images.shape		,	(
							        self.image_processor_tester.batch_size,
							        self.image_processor_tester.num_channels,
							        expected_height,
							        expected_width,
							    )		,	)

							# Test masking
							__UpperCAmelCase	:							Optional[int]     =     image_processing(UpperCAmelCase_		,	return_image_mask=UpperCAmelCase_		,	return_tensors="pt"		)

							__UpperCAmelCase  ,			__UpperCAmelCase	:							Optional[Any]     =     self.image_processor_tester.get_expected_image_size()
							self.assertEqual(
							    encoded_images.pixel_values.shape		,	(
							        self.image_processor_tester.batch_size,
							        self.image_processor_tester.num_channels,
							        expected_height,
							        expected_width,
							    )		,	)

							__UpperCAmelCase  ,			__UpperCAmelCase	:							str     =     self.image_processor_tester.get_expected_mask_size()
							self.assertEqual(
							    encoded_images.bool_masked_pos.shape		,	(
							        self.image_processor_tester.batch_size,
							        expected_height,
							        expected_width,
							    )		,	)
					def 		lowerCamelCase_   (   self       :      Optional[int]		):







							"""simple docstring"""
							self._test_call_framework(np.ndarray		,	prepare_kwargs={"numpify": True}		)
					def 		lowerCamelCase_   (   self       :      Dict		):







							"""simple docstring"""
							self._test_call_framework(torch.Tensor		,	prepare_kwargs={"torchify": True}		)
					def 		lowerCamelCase_   (   self       :      str		):







							"""simple docstring"""
							# Initialize image_processing
							random.seed(1_234		)
							__UpperCAmelCase	:							Union[str, Any]     =     self.image_processing_class(**self.image_processor_dict		)
							__UpperCAmelCase	:							Union[str, Any]     =     prepare_image_inputs(self.image_processor_tester		,	equal_resolution=UpperCAmelCase_		,	torchify=UpperCAmelCase_		)

							# Test not batched input
							__UpperCAmelCase	:							Any     =     image_processing(image_inputs[0]		,	return_image_mask=UpperCAmelCase_		,	return_tensors="pt"		)
							self.assertEqual(encoded_images.bool_masked_pos.sum().item()		,	75		)






					def 		lowerCamelCase_   (   self       :      List[str]		):







							"""simple docstring"""
							# Initialize image_processing
							__UpperCAmelCase	:							List[str]     =     self.image_processing_class(**self.image_processor_dict		)
							# create random PIL images
							__UpperCAmelCase	:							Optional[int]     =     prepare_image_inputs(self.image_processor_tester		,	equal_resolution=UpperCAmelCase_		)
							for image in image_inputs:
									self.assertIsInstance(UpperCAmelCase_		,	PIL.Image.Image		)

							# Test not batched input
							__UpperCAmelCase	:							int     =     image_processing(image_inputs[0]		,	return_codebook_pixels=UpperCAmelCase_		,	return_tensors="pt"		)
							__UpperCAmelCase  ,			__UpperCAmelCase	:							Optional[Any]     =     self.image_processor_tester.get_expected_codebook_image_size()
							self.assertEqual(
							    encoded_images.codebook_pixel_values.shape		,	(1, self.image_processor_tester.num_channels, expected_height, expected_width)		,	)

							# Test batched
							__UpperCAmelCase	:							Tuple     =     image_processing(UpperCAmelCase_		,	return_codebook_pixels=UpperCAmelCase_		,	return_tensors="pt"		)
							__UpperCAmelCase  ,			__UpperCAmelCase	:							Optional[Any]     =     self.image_processor_tester.get_expected_codebook_image_size()
							self.assertEqual(
							    encoded_images.codebook_pixel_values.shape		,	(
							        self.image_processor_tester.batch_size,
							        self.image_processor_tester.num_channels,
							        expected_height,
							        expected_width,
							    )		,	)










import argparse

from transformers import ConvBertConfig, ConvBertModel, TFConvBertModel, load_tf_weights_in_convbert
from transformers.utils import logging


logging.set_verbosity_info()
def        lowerCamelCase_     (     SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE     =       ConvBertConfig.from_json_file(SCREAMING_SNAKE_CASE )
			SCREAMING_SNAKE_CASE     =       ConvBertModel(SCREAMING_SNAKE_CASE )

			SCREAMING_SNAKE_CASE     =       load_tf_weights_in_convbert(SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE )
			model.save_pretrained(SCREAMING_SNAKE_CASE )

			SCREAMING_SNAKE_CASE     =       TFConvBertModel.from_pretrained(SCREAMING_SNAKE_CASE       ,						from_pt=SCREAMING_SNAKE_CASE )
			tf_model.save_pretrained(SCREAMING_SNAKE_CASE )


if __name__ == "__main__":
		__A    :				str    						=	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(
		    """--convbert_config_file""",
		    default=None,
		    type=str,
		    required=True,
		    help=(
		        """The config json file corresponding to the pre-trained ConvBERT model. \n"""
		        """This specifies the model architecture."""
		    ),
		)
		parser.add_argument(
		    """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
		)
		__A    :				List[Any]    						=	parser.parse_args()
		convert_orig_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.convbert_config_file, args.pytorch_dump_path)






