





"""simple docstring"""




import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation




class 			_a						(				unittest.TestCase    ):






				def     snake_case     (			self		:   Union[str, Any]							)     ->				Optional[int]:




										'''simple docstring'''



										_UpperCamelCase      : Dict         =   get_activation('''swish'''							)

										self.assertIsInstance(lowerCAmelCase__,			nn.SiLU							)

										self.assertEqual(act(torch.tensor(-1_0_0,			dtype=torch.floataa							)							).item(),			0							)
										self.assertNotEqual(act(torch.tensor(-1,			dtype=torch.floataa							)							).item(),			0							)
										self.assertEqual(act(torch.tensor(0,			dtype=torch.floataa							)							).item(),			0							)
										self.assertEqual(act(torch.tensor(2_0,			dtype=torch.floataa							)							).item(),			2_0							)






				def     snake_case     (			self		:   List[Any]							)     ->				str:




										'''simple docstring'''



										_UpperCamelCase      : Optional[Any]         =   get_activation('''silu'''							)

										self.assertIsInstance(lowerCAmelCase__,			nn.SiLU							)

										self.assertEqual(act(torch.tensor(-1_0_0,			dtype=torch.floataa							)							).item(),			0							)
										self.assertNotEqual(act(torch.tensor(-1,			dtype=torch.floataa							)							).item(),			0							)
										self.assertEqual(act(torch.tensor(0,			dtype=torch.floataa							)							).item(),			0							)
										self.assertEqual(act(torch.tensor(2_0,			dtype=torch.floataa							)							).item(),			2_0							)






				def     snake_case     (			self		:   Optional[int]							)     ->				str:




										'''simple docstring'''



										_UpperCamelCase      : Optional[Any]         =   get_activation('''mish'''							)

										self.assertIsInstance(lowerCAmelCase__,			nn.Mish							)

										self.assertEqual(act(torch.tensor(-2_0_0,			dtype=torch.floataa							)							).item(),			0							)
										self.assertNotEqual(act(torch.tensor(-1,			dtype=torch.floataa							)							).item(),			0							)
										self.assertEqual(act(torch.tensor(0,			dtype=torch.floataa							)							).item(),			0							)
										self.assertEqual(act(torch.tensor(2_0,			dtype=torch.floataa							)							).item(),			2_0							)






				def     snake_case     (			self		:   int							)     ->				List[str]:




										'''simple docstring'''



										_UpperCamelCase      : Union[str, Any]         =   get_activation('''gelu'''							)

										self.assertIsInstance(lowerCAmelCase__,			nn.GELU							)

										self.assertEqual(act(torch.tensor(-1_0_0,			dtype=torch.floataa							)							).item(),			0							)
										self.assertNotEqual(act(torch.tensor(-1,			dtype=torch.floataa							)							).item(),			0							)
										self.assertEqual(act(torch.tensor(0,			dtype=torch.floataa							)							).item(),			0							)
										self.assertEqual(act(torch.tensor(2_0,			dtype=torch.floataa							)							).item(),			2_0							)










"""simple docstring"""




import argparse

import torch

from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert
from transformers.utils import logging


logging.set_verbosity_info()





def 	a_    (							_lowercase	,						_lowercase	,						_lowercase       ):
						# Initialise PyTorch model
						_UpperCamelCase      : List[Any]         =   MobileBertConfig.from_json_file(_lowercase       )
						print(F"""Building PyTorch model from configuration: {config}"""       )
						_UpperCamelCase      : List[str]         =   MobileBertForPreTraining(_lowercase       )
						# Load weights from tf checkpoint
						_UpperCamelCase      : Union[str, Any]         =   load_tf_weights_in_mobilebert(_lowercase	,						_lowercase	,						_lowercase       )
						# Save pytorch-model
						print(F"""Save PyTorch model to {pytorch_dump_path}"""       )
						torch.save(model.state_dict()	,						_lowercase       )


if __name__ == "__main__":
						UpperCamelCase_									=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(
						    """--mobilebert_config_file""",
						    default=None,
						    type=str,
						    required=True,
						    help=(
						        """The config json file corresponding to the pre-trained MobileBERT 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."""
						)
						UpperCamelCase_									=parser.parse_args()
						convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)



