


# Copyright 2023 The HuggingFace Inc. 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.
import copy
import importlib.metadata
import json
import os
from dataclasses import dataclass
from typing import Any, Dict, Union

from packaging import version

from ..utils import is_torch_available, logging


if is_torch_available():
 import torch


SCREAMING_SNAKE_CASE			: Optional[int]				   =					logging.get_logger(__name__)






@dataclass
class _lowerCamelCase:
       def __init__(   self, lowerCamelCase=False, lowerCamelCase=False, lowerCamelCase=6.0, lowerCamelCase=None, lowerCamelCase=False, lowerCamelCase=False, lowerCamelCase=None, lowerCamelCase="fp4", lowerCamelCase=False, **lowerCamelCase, )			->  List[str]:




           """simple docstring"""

           _lowercase			:				Optional[Any] 						=						load_in_abit
           _lowercase			:				List[Any] 						=						load_in_abit
           _lowercase			:				Union[str, Any] 						=						llm_inta_threshold
           _lowercase			:				List[Any] 						=						llm_inta_skip_modules
           _lowercase			:				Any 						=						llm_inta_enable_fpaa_cpu_offload
           _lowercase			:				Tuple 						=						llm_inta_has_fpaa_weight
           _lowercase			:				Dict 						=						bnb_abit_quant_type
           _lowercase			:				List[str] 						=						bnb_abit_use_double_quant

           if bnb_abit_compute_dtype is None:
               _lowercase			:				Union[str, Any] 						=						torch.floataa
           elif isinstance(lowerCamelCase, lowerCamelCase):
               _lowercase			:				Tuple 						=						getattr(lowerCamelCase, lowerCamelCase)
           elif isinstance(lowerCamelCase, torch.dtype):
               _lowercase			:				int 						=						bnb_abit_compute_dtype
           else:
               raise ValueError('bnb_4bit_compute_dtype must be a string or a torch.dtype')

           self.post_init()
       def      UpperCamelCase	(   self)			->  List[Any]:




           """simple docstring"""

           if not isinstance(self.llm_inta_threshold, lowerCamelCase):
               raise ValueError('llm_int8_threshold must be a float')

           if self.llm_inta_skip_modules is not None and not isinstance(self.llm_inta_skip_modules, lowerCamelCase):
               raise ValueError('llm_int8_skip_modules must be a list of strings')
           if not isinstance(self.llm_inta_enable_fpaa_cpu_offload, lowerCamelCase):
               raise ValueError('llm_int8_enable_fp32_cpu_offload must be a boolean')

           if not isinstance(self.llm_inta_has_fpaa_weight, lowerCamelCase):
               raise ValueError('llm_int8_has_fp16_weight must be a boolean')

           if self.bnb_abit_compute_dtype is not None and not isinstance(self.bnb_abit_compute_dtype, torch.dtype):
               raise ValueError('bnb_4bit_compute_dtype must be torch.dtype')

           if not isinstance(self.bnb_abit_quant_type, lowerCamelCase):
               raise ValueError('bnb_4bit_quant_type must be a string')

           if not isinstance(self.bnb_abit_use_double_quant, lowerCamelCase):
               raise ValueError('bnb_4bit_use_double_quant must be a boolean')

           if self.load_in_abit and not version.parse(importlib.metadata.version('bitsandbytes')) >= version.parse(
               '0.39.0'):
               raise ValueError(
                   '4 bit quantization requires bitsandbytes>=0.39.0 - please upgrade your bitsandbytes version')
       def      UpperCamelCase	(   self)			->  int:




           """simple docstring"""

           return self.load_in_abit or self.load_in_abit
       def      UpperCamelCase	(   self)			->  Optional[int]:




           """simple docstring"""

           if self.load_in_abit:
               return "llm_int8"
           elif self.load_in_abit and self.bnb_abit_quant_type == "fp4":
               return "fp4"
           elif self.load_in_abit and self.bnb_abit_quant_type == "nf4":
               return "nf4"
           else:
               return None
       @classmethod
       def      UpperCamelCase	(   cls, lowerCamelCase, lowerCamelCase, **lowerCamelCase)			->  List[str]:




           """simple docstring"""

           _lowercase			:				Optional[int] 						=						cls(**lowerCamelCase)

           _lowercase			:				int 						=						[]
           for key, value in kwargs.items():
               if hasattr(lowerCamelCase, lowerCamelCase):
                   setattr(lowerCamelCase, lowerCamelCase, lowerCamelCase)
                   to_remove.append(lowerCamelCase)
           for key in to_remove:
               kwargs.pop(lowerCamelCase, lowerCamelCase)

           if return_unused_kwargs:
               return config, kwargs
           else:
               return config
       def      UpperCamelCase	(   self, lowerCamelCase)			->  Optional[int]:




           """simple docstring"""

           with open(lowerCamelCase, 'w', encoding='utf-8') as writer:
               _lowercase			:				Union[str, Any] 						=						self.to_dict()
               _lowercase			:				int 						=						json.dumps(lowerCamelCase, indent=2, sort_keys=lowerCamelCase) + '\n'

               writer.write(lowerCamelCase)
       def      UpperCamelCase	(   self)			->  Dict[str, Any]:




           """simple docstring"""

           _lowercase			:				Dict 						=						copy.deepcopy(self.__dict__)
           _lowercase			:				str 						=						str(output['bnb_4bit_compute_dtype']).split('.')[1]

           return output
       def __repr__(   self)			->  Any:




           """simple docstring"""

           return F'''{self.__class__.__name__} {self.to_json_string()}'''
       def      UpperCamelCase	(   self, lowerCamelCase = True)			->  str:




           """simple docstring"""

           if use_diff is True:
               _lowercase			:				int 						=						self.to_diff_dict()
           else:
               _lowercase			:				List[str] 						=						self.to_dict()
           return json.dumps(lowerCamelCase, indent=2, sort_keys=lowerCamelCase) + "\n"




       def      UpperCamelCase	(   self)			->  Dict[str, Any]:




           """simple docstring"""

           _lowercase			:				Optional[Any] 						=						self.to_dict()

           # get the default config dict
           _lowercase			:				Optional[Any] 						=						BitsAndBytesConfig().to_dict()

           _lowercase			:				str 						=						{}

           # only serialize values that differ from the default config
           for key, value in config_dict.items():
               if value != default_config_dict[key]:
                   _lowercase			:				Dict 						=						value

           return serializable_config_dict






import argparse

from transformers import TaConfig, TaForConditionalGeneration, load_tf_weights_in_ta
from transformers.utils import logging


logging.set_verbosity_info()



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_					)       ->		Optional[int]:
    # Initialise PyTorch model
    _lowercase			:				Optional[int] 						=						TaConfig.from_json_file(lowerCamelCase_					)
    print(F'''Building PyTorch model from configuration: {config}'''					)
    _lowercase			:				Union[str, Any] 						=						TaForConditionalGeneration(lowerCamelCase_					)

    # Load weights from tf checkpoint
    load_tf_weights_in_ta(lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_					)

    # Save pytorch-model
    print(F'''Save PyTorch model to {pytorch_dump_path}'''					)
    model.save_pretrained(lowerCamelCase_					)


if __name__ == "__main__":
 SCREAMING_SNAKE_CASE			: Optional[int]				   =					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 T5 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."
 )
 SCREAMING_SNAKE_CASE			: Any				   =					parser.parse_args()
 convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)


