


'''simple docstring'''




from __future__ import annotations

import unittest

from transformers import OpenAIGPTConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
       import tensorflow as tf

       from transformers.models.openai.modeling_tf_openai import (
           TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
           TFOpenAIGPTDoubleHeadsModel,
           TFOpenAIGPTForSequenceClassification,
           TFOpenAIGPTLMHeadModel,
           TFOpenAIGPTModel,
       )




class  _lowercase   :
   def __init__(	self					:			str					,      SCREAMING_SNAKE_CASE_					:			List[str]					,      )   ->       Tuple:
        __snake_case    			=	parent
        __snake_case    			=	13
        __snake_case    			=	7
        __snake_case    			=	True
        __snake_case    			=	True
        __snake_case    			=	True
        __snake_case    			=	True
        __snake_case    			=	True
        __snake_case    			=	99
        __snake_case    			=	32
        __snake_case    			=	2
        __snake_case    			=	4
        __snake_case    			=	37
        __snake_case    			=	'gelu'
        __snake_case    			=	0.1
        __snake_case    			=	0.1
        __snake_case    			=	512
        __snake_case    			=	16
        __snake_case    			=	2
        __snake_case    			=	0.0_2
        __snake_case    			=	3
        __snake_case    			=	4
        __snake_case    			=	None
        __snake_case    			=	self.vocab_size - 1
   def a     (	self					:			Optional[int]			)   ->       int:
        __snake_case    			=	ids_tensor([self.batch_size, self.seq_length]					,      self.vocab_size			)

        __snake_case    			=	None
        if self.use_input_mask:
             __snake_case    			=	random_attention_mask([self.batch_size, self.seq_length]			)

        __snake_case    			=	None
        if self.use_token_type_ids:
             __snake_case    			=	ids_tensor([self.batch_size, self.seq_length]					,      self.type_vocab_size			)

        __snake_case    			=	None
        if self.use_mc_token_ids:
             __snake_case    			=	ids_tensor([self.batch_size, self.num_choices]					,      self.seq_length			)

        __snake_case    			=	None
        __snake_case    			=	None
        __snake_case    			=	None
        if self.use_labels:
             __snake_case    			=	ids_tensor([self.batch_size]					,      self.type_sequence_label_size			)
             __snake_case    			=	ids_tensor([self.batch_size, self.seq_length]					,      self.num_labels			)
             __snake_case    			=	ids_tensor([self.batch_size]					,      self.num_choices			)

        __snake_case    			=	OpenAIGPTConfig(
            vocab_size=self.vocab_size					,      n_embd=self.hidden_size					,      n_layer=self.num_hidden_layers					,      n_head=self.num_attention_heads					,      n_positions=self.max_position_embeddings					,      pad_token_id=self.pad_token_id					,      )

        __snake_case    			=	ids_tensor([self.num_hidden_layers, self.num_attention_heads]					,      2			)

        return (
            config,
            input_ids,
            input_mask,
            head_mask,
            token_type_ids,
            mc_token_ids,
            sequence_labels,
            token_labels,
            choice_labels,
        )
   def a     (	self					:			List[str]					,      SCREAMING_SNAKE_CASE_					:			int					,      SCREAMING_SNAKE_CASE_					:			Optional[int]					,      SCREAMING_SNAKE_CASE_					:			Tuple					,      SCREAMING_SNAKE_CASE_					:			Any					,      SCREAMING_SNAKE_CASE_					:			Dict					,      *SCREAMING_SNAKE_CASE_					:			Union[str, Any]			)   ->       int:
        __snake_case    			=	TFOpenAIGPTModel(config=SCREAMING_SNAKE_CASE_			)
        __snake_case    			=	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
        __snake_case    			=	model(SCREAMING_SNAKE_CASE_			)

        __snake_case    			=	[input_ids, input_mask]
        __snake_case    			=	model(SCREAMING_SNAKE_CASE_			)

        __snake_case    			=	model(SCREAMING_SNAKE_CASE_			)

        self.parent.assertEqual(result.last_hidden_state.shape					,      (self.batch_size, self.seq_length, self.hidden_size)			)
   def a     (	self					:			Dict					,      SCREAMING_SNAKE_CASE_					:			Tuple					,      SCREAMING_SNAKE_CASE_					:			Tuple					,      SCREAMING_SNAKE_CASE_					:			Optional[Any]					,      SCREAMING_SNAKE_CASE_					:			str					,      SCREAMING_SNAKE_CASE_					:			Dict					,      *SCREAMING_SNAKE_CASE_					:			Optional[int]			)   ->       Union[str, Any]:
        __snake_case    			=	TFOpenAIGPTLMHeadModel(config=SCREAMING_SNAKE_CASE_			)
        __snake_case    			=	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
        __snake_case    			=	model(SCREAMING_SNAKE_CASE_			)
        self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.seq_length, self.vocab_size)			)
   def a     (	self					:			List[str]					,      SCREAMING_SNAKE_CASE_					:			List[Any]					,      SCREAMING_SNAKE_CASE_					:			Optional[int]					,      SCREAMING_SNAKE_CASE_					:			Any					,      SCREAMING_SNAKE_CASE_					:			Any					,      SCREAMING_SNAKE_CASE_					:			Any					,      SCREAMING_SNAKE_CASE_					:			Optional[Any]					,      *SCREAMING_SNAKE_CASE_					:			Optional[int]			)   ->       Union[str, Any]:
        __snake_case    			=	TFOpenAIGPTDoubleHeadsModel(config=SCREAMING_SNAKE_CASE_			)

        __snake_case    			=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE_					,      1			)					,      (1, self.num_choices, 1)			)
        __snake_case    			=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE_					,      1			)					,      (1, self.num_choices, 1)			)
        __snake_case    			=	tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE_					,      1			)					,      (1, self.num_choices, 1)			)

        __snake_case    			=	{
            'input_ids': multiple_choice_inputs_ids,
            'mc_token_ids': mc_token_ids,
            'attention_mask': multiple_choice_input_mask,
            'token_type_ids': multiple_choice_token_type_ids,
        }
        __snake_case    			=	model(SCREAMING_SNAKE_CASE_			)
        self.parent.assertEqual(
            result.logits.shape					,      (self.batch_size, self.num_choices, self.seq_length, self.vocab_size)			)
        self.parent.assertEqual(result.mc_logits.shape					,      (self.batch_size, self.num_choices)			)
   def a     (	self					:			Optional[int]					,      SCREAMING_SNAKE_CASE_					:			Optional[Any]					,      SCREAMING_SNAKE_CASE_					:			Any					,      SCREAMING_SNAKE_CASE_					:			Dict					,      SCREAMING_SNAKE_CASE_					:			int					,      SCREAMING_SNAKE_CASE_					:			Any					,      *SCREAMING_SNAKE_CASE_					:			List[Any]			)   ->       Dict:
        __snake_case    			=	self.num_labels
        __snake_case    			=	ids_tensor([self.batch_size]					,      self.type_sequence_label_size			)
        __snake_case    			=	{
            'input_ids': input_ids,
            'attention_mask': input_mask,
            'token_type_ids': token_type_ids,
            'labels': sequence_labels,
        }
        __snake_case    			=	TFOpenAIGPTForSequenceClassification(SCREAMING_SNAKE_CASE_			)
        __snake_case    			=	model(SCREAMING_SNAKE_CASE_			)
        self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.num_labels)			)





   def a     (	self					:			str			)   ->       Tuple:
        __snake_case    			=	self.prepare_config_and_inputs()

        (
            (
            __snake_case
        )			,					(
            __snake_case
        )			,					(
            __snake_case
        )			,					(
            __snake_case
        )			,					(
            __snake_case
        )			,					(
            __snake_case
        )			,					(
            __snake_case
        )			,					(
            __snake_case
        )			,					(
            __snake_case
        )			,					
        )    			=	config_and_inputs

        __snake_case    			=	{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
        return config, inputs_dict




@require_tf
class  _lowercase   (  __lowercase	,				__lowercase	,				unittest.TestCase       ):
   _SCREAMING_SNAKE_CASE     :     Optional[Any]									=  (
       (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
       if is_tf_available()
       else ()
   )
   _SCREAMING_SNAKE_CASE     :     Tuple									=  (
       (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
   )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
   _SCREAMING_SNAKE_CASE     :     List[Any]									=  (
       {
           "feature-extraction": TFOpenAIGPTModel,
           "text-classification": TFOpenAIGPTForSequenceClassification,
           "text-generation": TFOpenAIGPTLMHeadModel,
           "zero-shot": TFOpenAIGPTForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   _SCREAMING_SNAKE_CASE     :     Any									=  False
   _SCREAMING_SNAKE_CASE     :     Tuple									=  False
   def a     (	self					:			Dict					,      SCREAMING_SNAKE_CASE_					:			Dict					,      SCREAMING_SNAKE_CASE_					:			Dict					,      SCREAMING_SNAKE_CASE_					:			Optional[int]					,      SCREAMING_SNAKE_CASE_					:			Any					,      SCREAMING_SNAKE_CASE_					:			str			)   ->       Dict:
        if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
             # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
             # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
             # tiny config could not be created.
             return True

        return False
   def a     (	self					:			Union[str, Any]			)   ->       Optional[int]:
        __snake_case    			=	TFOpenAIGPTModelTester(self			)
        __snake_case    			=	ConfigTester(self					,      config_class=SCREAMING_SNAKE_CASE_					,      n_embd=37			)
   def a     (	self					:			Tuple			)   ->       str:
        self.config_tester.run_common_tests()
   def a     (	self					:			Any			)   ->       Dict:
        __snake_case    			=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_openai_gpt_model(*SCREAMING_SNAKE_CASE_			)
   def a     (	self					:			int			)   ->       Optional[int]:
        __snake_case    			=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_openai_gpt_lm_head(*SCREAMING_SNAKE_CASE_			)
   def a     (	self					:			Tuple			)   ->       List[str]:
        __snake_case    			=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_openai_gpt_double_head(*SCREAMING_SNAKE_CASE_			)
   def a     (	self					:			Tuple			)   ->       Union[str, Any]:
        __snake_case    			=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*SCREAMING_SNAKE_CASE_			)





   @slow
   def a     (	self					:			Tuple			)   ->       Union[str, Any]:
        for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             __snake_case    			=	TFOpenAIGPTModel.from_pretrained(SCREAMING_SNAKE_CASE_			)
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_			)




@require_tf
class  _lowercase   (  unittest.TestCase       ):
   @slow
   def a     (	self					:			Optional[int]			)   ->       str:
        __snake_case    			=	TFOpenAIGPTLMHeadModel.from_pretrained('openai-gpt'			)
        __snake_case    			=	tf.convert_to_tensor([[481, 4735, 544]]					,      dtype=tf.intaa			)  # the president is
        __snake_case    			=	[
            481,
            4735,
            544,
            246,
            963,
            870,
            762,
            239,
            244,
            4_0477,
            244,
            249,
            719,
            881,
            487,
            544,
            240,
            244,
            603,
            481,
        ]  # the president is a very good man. " \n " i\'m sure he is, " said the

        __snake_case    			=	model.generate(SCREAMING_SNAKE_CASE_					,      do_sample=SCREAMING_SNAKE_CASE_			)
        self.assertListEqual(output_ids[0].numpy().tolist()					,      SCREAMING_SNAKE_CASE_			)








'''simple docstring'''




import argparse
import json
import re
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    MobileNetVaConfig,
    MobileNetVaForImageClassification,
    MobileNetVaForSemanticSegmentation,
    MobileNetVaImageProcessor,
    load_tf_weights_in_mobilenet_va,
)
from transformers.utils import logging


logging.set_verbosity_info()
_a      :      int       				=      logging.get_logger(__name__)





def      _a		(lowercase__ :      int	) -> Union[str, Any]:






     """simple docstring"""
     __snake_case    			=	MobileNetVaConfig(layer_norm_eps=0.0_01	)

     if "quant" in model_name:
          raise ValueError('Quantized models are not supported.'	)

     __snake_case    			=	re.match(r'^.*mobilenet_v2_([^_]*)_([^_]*)$'       ,      lowercase__	)
     if matches:
          __snake_case    			=	float(matches[1]	)
          __snake_case    			=	int(matches[2]	)

     if model_name.startswith('deeplabv3_'	):
          __snake_case    			=	8
          __snake_case    			=	2_1
          __snake_case    			=	'pascal-voc-id2label.json'
     else:
          # The TensorFlow version of MobileNetV2 predicts 1001 classes instead
          # of the usual 1000. The first class (index 0) is "background".
          __snake_case    			=	1_0_0_1
          __snake_case    			=	'imagenet-1k-id2label.json'

     __snake_case    			=	'huggingface/label-files'
     __snake_case    			=	json.load(open(hf_hub_download(lowercase__       ,      lowercase__       ,      repo_type='dataset'	)       ,      'r'	)	)

     if config.num_labels == 1_0_0_1:
          __snake_case    			=	{int(lowercase__	) + 1: v for k, v in idalabel.items()}
          __snake_case    			=	'background'
     else:
          __snake_case    			=	{int(lowercase__	): v for k, v in idalabel.items()}

     __snake_case    			=	idalabel
     __snake_case    			=	{v: k for k, v in idalabel.items()}

     return config





def      _a		() -> Dict:






     """simple docstring"""
     __snake_case    			=	'http://images.cocodataset.org/val2017/000000039769.jpg'
     __snake_case    			=	Image.open(requests.get(lowercase__       ,      stream=lowercase__	).raw	)
     return im





@torch.no_grad()
def      _a		(lowercase__ :      str       ,      lowercase__ :      Optional[int]       ,      lowercase__ :      Optional[Any]       ,      lowercase__ :      Dict=False	) -> Any:






     """simple docstring"""
     __snake_case    			=	get_mobilenet_va_config(lowercase__	)

     # Load 🤗 model
     if model_name.startswith('deeplabv3_'	):
          __snake_case    			=	MobileNetVaForSemanticSegmentation(lowercase__	).eval()
     else:
          __snake_case    			=	MobileNetVaForImageClassification(lowercase__	).eval()

     # Load weights from TensorFlow checkpoint
     load_tf_weights_in_mobilenet_va(lowercase__       ,      lowercase__       ,      lowercase__	)

     # Check outputs on an image, prepared by MobileNetV2ImageProcessor
     __snake_case    			=	MobileNetVaImageProcessor(
         crop_size={'width': config.image_size, 'height': config.image_size}       ,      size={'shortest_edge': config.image_size + 3_2}       ,      )
     __snake_case    			=	image_processor(images=prepare_img()       ,      return_tensors='pt'	)
     __snake_case    			=	model(**lowercase__	)
     __snake_case    			=	outputs.logits

     if model_name.startswith('deeplabv3_'	):
          assert logits.shape == (1, 2_1, 6_5, 6_5)

          if model_name == "deeplabv3_mobilenet_v2_1.0_513":
               __snake_case    			=	torch.tensor(
                   [
                       [[17.57_90, 17.75_81, 18.33_55], [18.32_57, 18.42_30, 18.89_73], [18.61_69, 18.86_50, 19.21_87]],
                       [[-2.15_95, -2.09_77, -2.37_41], [-2.42_26, -2.30_28, -2.68_35], [-2.78_19, -2.59_91, -2.77_06]],
                       [[4.20_58, 4.83_17, 4.76_38], [4.41_36, 5.03_61, 4.93_83], [4.50_28, 4.96_44, 4.87_34]],
                   ]	)

          else:
               raise ValueError(f'Unknown model name: {model_name}'	)

          assert torch.allclose(logits[0, :3, :3, :3]       ,      lowercase__       ,      atol=1e-4	)
     else:
          assert logits.shape == (1, 1_0_0_1)

          if model_name == "mobilenet_v2_1.4_224":
               __snake_case    			=	torch.tensor([0.01_81, -1.00_15, 0.46_88]	)
          elif model_name == "mobilenet_v2_1.0_224":
               __snake_case    			=	torch.tensor([0.24_45, -1.19_93, 0.19_05]	)
          elif model_name == "mobilenet_v2_0.75_160":
               __snake_case    			=	torch.tensor([0.24_82, 0.41_36, 0.66_69]	)
          elif model_name == "mobilenet_v2_0.35_96":
               __snake_case    			=	torch.tensor([0.14_51, -0.46_24, 0.71_92]	)
          else:
               __snake_case    			=	None

          if expected_logits is not None:
               assert torch.allclose(logits[0, :3]       ,      lowercase__       ,      atol=1e-4	)

     Path(lowercase__	).mkdir(exist_ok=lowercase__	)
     print(f'Saving model {model_name} to {pytorch_dump_folder_path}'	)
     model.save_pretrained(lowercase__	)
     print(f'Saving image processor to {pytorch_dump_folder_path}'	)
     image_processor.save_pretrained(lowercase__	)

     if push_to_hub:
          print('Pushing to the hub...'	)
          __snake_case    			=	'google/' + model_name
          image_processor.push_to_hub(lowercase__	)
          model.push_to_hub(lowercase__	)


if __name__ == "__main__":
       _a      :      List[str]       				=      argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           "--model_name",
           default="mobilenet_v2_1.0_224",
           type=str,
           help="Name of the MobileNetV2 model you'd like to convert. Should in the form 'mobilenet_v2_<depth>_<size>'.",
       )
       parser.add_argument(
           "--checkpoint_path", required=True, type=str, help="Path to the original TensorFlow checkpoint (.ckpt file)."
       )
       parser.add_argument(
           "--pytorch_dump_folder_path", required=True, type=str, help="Path to the output PyTorch model directory."
       )
       parser.add_argument(
           "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
       )

       _a      :      str       				=      parser.parse_args()
       convert_movilevit_checkpoint(
           args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
       )




