


'''simple docstring'''







import argparse

import torch

from transformers import ElectraConfig, ElectraForMaskedLM, ElectraForPreTraining, load_tf_weights_in_electra
from transformers.utils import logging


logging.set_verbosity_info()







def _UpperCamelCase	(					__A				,      __A				,      __A				,      __A   )							->		Any:


      '''simple docstring'''



      UpperCamelCase__  =    ElectraConfig.from_json_file(__A   )
      print(F'''Building PyTorch model from configuration: {config}'''   )

      if discriminator_or_generator == "discriminator":
            UpperCamelCase__  =    ElectraForPreTraining(__A   )
      elif discriminator_or_generator == "generator":
            UpperCamelCase__  =    ElectraForMaskedLM(__A   )
      else:
            raise ValueError("The discriminator_or_generator argument should be either 'discriminator' or 'generator'"   )

      # Load weights from tf checkpoint
      load_tf_weights_in_electra(
          __A				,      __A				,      __A				,      discriminator_or_generator=__A   )

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


if __name__ == "__main__":
  a__  : Union[str, Any]				=	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(
      '--discriminator_or_generator',
      default=None,
      type=str,
      required=True,
      help=(
          'Whether to export the generator or the discriminator. Should be a string, either \'discriminator\' or '
          '\'generator\'.'
      ),
  )
  a__  : Tuple				=	parser.parse_args()
  convert_tf_checkpoint_to_pytorch(
      args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
  )









'''simple docstring'''







# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
    is_vision_available,
)


a__  : Any				=	{
    'configuration_tvlt': ['TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TvltConfig'],
    'feature_extraction_tvlt': ['TvltFeatureExtractor'],
    'processing_tvlt': ['TvltProcessor'],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a__  : int				=	[
      'TVLT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TvltModel',
      'TvltForPreTraining',
      'TvltForAudioVisualClassification',
      'TvltPreTrainedModel',
  ]

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a__  : List[Any]				=	['TvltImageProcessor']


if TYPE_CHECKING:
  from .configuration_tvlt import TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP, TvltConfig
  from .processing_tvlt import TvltProcessor
  from .feature_extraction_tvlt import TvltFeatureExtractor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tvlt import (
        TVLT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TvltForAudioVisualClassification,
        TvltForPreTraining,
        TvltModel,
        TvltPreTrainedModel,
    )

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_tvlt import TvltImageProcessor


else:
  import sys

  a__  : Any				=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





