






"""simple docstring"""







from typing import List, Union

import numpy as np

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, logging
from .base import PIPELINE_INIT_ARGS, ArgumentHandler, ChunkPipeline


_UpperCamelCase					      =  logging.get_logger(__name__)







class  lowerCamelCase__ (	__UpperCamelCase			):






    def     _UpperCamelCase							(			self     ,A ):
          if isinstance(A     ,A ):
                UpperCAmelCase          =	[label.strip() for label in labels.split(""",""" ) if label.strip()]
          return labels






    def __call__(			self     ,A     ,A     ,A ):
          if len(A ) == 0 or len(A ) == 0:
                raise ValueError("""You must include at least one label and at least one sequence.""" )
          if hypothesis_template.format(labels[0] ) == hypothesis_template:
                raise ValueError(
                    (
                        """The provided hypothesis_template \"{}\" was not able to be formatted with the target labels. """
                        """Make sure the passed template includes formatting syntax such as {{}} where the label should go."""
                    ).format(A ) )

          if isinstance(A     ,A ):
                UpperCAmelCase          =	[sequences]

          UpperCAmelCase          =	[]
          for sequence in sequences:
                sequence_pairs.extend([[sequence, hypothesis_template.format(A )] for label in labels] )

          return sequence_pairs, sequences







@add_end_docstrings(__UpperCamelCase			)
class  lowerCamelCase__ (	__UpperCamelCase			):






    def __init__(			self     ,A=ZeroShotClassificationArgumentHandler()     ,*A     ,**A ):
          UpperCAmelCase          =	args_parser
          super().__init__(*A     ,**A )
          if self.entailment_id == -1:
                logger.warning(
                    """Failed to determine 'entailment' label id from the label2id mapping in the model config. Setting to """
                    """-1. Define a descriptive label2id mapping in the model config to ensure correct outputs.""" )






    @property
    def     _UpperCamelCase							(			self ):
          for label, ind in self.model.config.labelaid.items():
                if label.lower().startswith("""entail""" ):
                      return ind
          return -1






    def     _UpperCamelCase							(			self     ,A     ,A=True     ,A=True     ,A=TruncationStrategy.ONLY_FIRST     ,**A ):
          UpperCAmelCase          =	self.framework
          if self.tokenizer.pad_token is None:
                # Override for tokenizers not supporting padding
                logger.error(
                    """Tokenizer was not supporting padding necessary for zero-shot, attempting to use """
                    """ `pad_token=eos_token`""" )
                UpperCAmelCase          =	self.tokenizer.eos_token
          try:
                UpperCAmelCase          =	self.tokenizer(
                    A     ,add_special_tokens=A     ,return_tensors=A     ,padding=A     ,truncation=A     ,)
          except Exception as e:
                if "too short" in str(A ):
                      # tokenizers might yell that we want to truncate
                      # to a value that is not even reached by the input.
                      # In that case we don't want to truncate.
                      # It seems there's not a really better way to catch that
                      # exception.

                      UpperCAmelCase          =	self.tokenizer(
                          A     ,add_special_tokens=A     ,return_tensors=A     ,padding=A     ,truncation=TruncationStrategy.DO_NOT_TRUNCATE     ,)
                else:
                      raise e

          return inputs






    def     _UpperCamelCase							(			self     ,**A ):
          if kwargs.get("""multi_class"""     ,A ) is not None:
                UpperCAmelCase          =	kwargs["""multi_class"""]
                logger.warning(
                    """The `multi_class` argument has been deprecated and renamed to `multi_label`. """
                    """`multi_class` will be removed in a future version of Transformers.""" )
          UpperCAmelCase          =	{}
          if "candidate_labels" in kwargs:
                UpperCAmelCase          =	self._args_parser._parse_labels(kwargs["""candidate_labels"""] )
          if "hypothesis_template" in kwargs:
                UpperCAmelCase          =	kwargs["""hypothesis_template"""]

          UpperCAmelCase          =	{}
          if "multi_label" in kwargs:
                UpperCAmelCase          =	kwargs["""multi_label"""]
          return preprocess_params, {}, postprocess_params






    def __call__(			self     ,A     ,*A     ,**A     ,):
          if len(A ) == 0:
                pass
          elif len(A ) == 1 and "candidate_labels" not in kwargs:
                UpperCAmelCase          =	args[0]
          else:
                raise ValueError(F'''Unable to understand extra arguments {args}''' )

          return super().__call__(A     ,**A )






    def     _UpperCamelCase							(			self     ,A     ,A=None     ,A="This example is {}." ):
          UpperCAmelCase          =	self._args_parser(A     ,A     ,A )

          for i, (candidate_label, sequence_pair) in enumerate(zip(A     ,A ) ):
                UpperCAmelCase          =	self._parse_and_tokenize([sequence_pair] )

                yield {
                    "candidate_label": candidate_label,
                    "sequence": sequences[0],
                    "is_last": i == len(A ) - 1,
                    **model_input,
                }






    def     _UpperCamelCase							(			self     ,A ):
          UpperCAmelCase          =	inputs["""candidate_label"""]
          UpperCAmelCase          =	inputs["""sequence"""]
          UpperCAmelCase          =	{k: inputs[k] for k in self.tokenizer.model_input_names}
          UpperCAmelCase          =	self.model(**A )

          UpperCAmelCase          =	{
              """candidate_label""": candidate_label,
              """sequence""": sequence,
              """is_last""": inputs["""is_last"""],
              **outputs,
          }
          return model_outputs






    def     _UpperCamelCase							(			self     ,A     ,A=False ):
          UpperCAmelCase          =	[outputs["""candidate_label"""] for outputs in model_outputs]
          UpperCAmelCase          =	[outputs["""sequence"""] for outputs in model_outputs]
          UpperCAmelCase          =	np.concatenate([output["""logits"""].numpy() for output in model_outputs] )
          UpperCAmelCase          =	logits.shape[0]
          UpperCAmelCase          =	len(A )
          UpperCAmelCase          =	N // n
          UpperCAmelCase          =	logits.reshape((num_sequences, n, -1) )

          if multi_label or len(A ) == 1:
                # softmax over the entailment vs. contradiction dim for each label independently
                UpperCAmelCase          =	self.entailment_id
                UpperCAmelCase          =	-1 if entailment_id == 0 else 0
                UpperCAmelCase          =	reshaped_outputs[..., [contradiction_id, entailment_id]]
                UpperCAmelCase          =	np.exp(A ) / np.exp(A ).sum(-1     ,keepdims=A )
                UpperCAmelCase          =	scores[..., 1]
          else:
                # softmax the "entailment" logits over all candidate labels
                UpperCAmelCase          =	reshaped_outputs[..., self.entailment_id]
                UpperCAmelCase          =	np.exp(A ) / np.exp(A ).sum(-1     ,keepdims=A )

          UpperCAmelCase          =	list(reversed(scores[0].argsort() ) )
          return {
              "sequence": sequences[0],
              "labels": [candidate_labels[i] for i in top_inds],
              "scores": scores[0, top_inds].tolist(),
          }











"""simple docstring"""







import argparse
import gc
import json
import os
import shutil
import warnings

import torch

from transformers import LlamaConfig, LlamaForCausalLM, LlamaTokenizer


try:
  from transformers import LlamaTokenizerFast
except ImportError as e:
  warnings.warn(e)
  warnings.warn(
      """The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion"""
  )
  _UpperCamelCase					      =  None
_UpperCamelCase					      =  {
    """7B""": 11008,
    """13B""": 13824,
    """30B""": 17920,
    """65B""": 22016,
    """70B""": 28672,
}
_UpperCamelCase					      =  {
    """7B""": 1,
    """7Bf""": 1,
    """13B""": 2,
    """13Bf""": 2,
    """30B""": 4,
    """65B""": 8,
    """70B""": 8,
    """70Bf""": 8,
}

def _a			(		_snake_case				,	_snake_case=1				,	_snake_case=256							):







      """simple docstring"""






      return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3							)							) + multiple_of - 1) // multiple_of)

def _a			(		_snake_case							):







      """simple docstring"""






      with open(_snake_case				,	"""r"""							) as f:
            return json.load(_snake_case							)

def _a			(		_snake_case				,	_snake_case							):







      """simple docstring"""






      with open(_snake_case				,	"""w"""							) as f:
            json.dump(_snake_case				,	_snake_case							)

def _a			(		_snake_case				,	_snake_case				,	_snake_case				,	_snake_case=True							):







      """simple docstring"""






      os.makedirs(_snake_case				,	exist_ok=_snake_case							)
      UpperCAmelCase          =	os.path.join(_snake_case				,	"""tmp"""							)
      os.makedirs(_snake_case				,	exist_ok=_snake_case							)

      UpperCAmelCase          =	read_json(os.path.join(_snake_case				,	"""params.json"""							)							)
      UpperCAmelCase          =	NUM_SHARDS[model_size]
      UpperCAmelCase          =	params["""n_layers"""]
      UpperCAmelCase          =	params["""n_heads"""]
      UpperCAmelCase          =	n_heads // num_shards
      UpperCAmelCase          =	params["""dim"""]
      UpperCAmelCase          =	dim // n_heads
      UpperCAmelCase          =	10000.0
      UpperCAmelCase          =	1.0 / (base ** (torch.arange(0				,	_snake_case				,	2							).float() / dims_per_head))

      if "n_kv_heads" in params:
            UpperCAmelCase          =	params["""n_kv_heads"""]  # for GQA / MQA
            UpperCAmelCase          =	n_heads_per_shard // num_key_value_heads
            UpperCAmelCase          =	dim // num_key_value_heads
      else:  # compatibility with other checkpoints
            UpperCAmelCase          =	n_heads
            UpperCAmelCase          =	n_heads_per_shard
            UpperCAmelCase          =	dim

      # permute for sliced rotary
      def permute(_snake_case				,	_snake_case=n_heads				,	_snake_case=dim				,	_snake_case=dim							):
            return w.view(_snake_case				,	dima // n_heads // 2				,	2				,	_snake_case							).transpose(1				,	2							).reshape(_snake_case				,	_snake_case							)

      print(F'''Fetching all parameters from the checkpoint at {input_base_path}.'''							)
      # Load weights
      if model_size == "7B":
            # Not sharded
            # (The sharded implementation would also work, but this is simpler.)
            UpperCAmelCase          =	torch.load(os.path.join(_snake_case				,	"""consolidated.00.pth"""							)				,	map_location="""cpu"""							)
      else:
            # Sharded
            UpperCAmelCase          =	[
                torch.load(os.path.join(_snake_case				,	F'''consolidated.{i:02d}.pth'''							)				,	map_location="""cpu"""							)
                for i in range(_snake_case							)
            ]
      UpperCAmelCase          =	0
      UpperCAmelCase          =	{"""weight_map""": {}}
      for layer_i in range(_snake_case							):
            UpperCAmelCase          =	F'''pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin'''
            if model_size == "7B":
                  # Unsharded
                  UpperCAmelCase          =	{
                      F'''model.layers.{layer_i}.self_attn.q_proj.weight''': permute(
                          loaded[F'''layers.{layer_i}.attention.wq.weight''']							),
                      F'''model.layers.{layer_i}.self_attn.k_proj.weight''': permute(
                          loaded[F'''layers.{layer_i}.attention.wk.weight''']							),
                      F'''model.layers.{layer_i}.self_attn.v_proj.weight''': loaded[F'''layers.{layer_i}.attention.wv.weight'''],
                      F'''model.layers.{layer_i}.self_attn.o_proj.weight''': loaded[F'''layers.{layer_i}.attention.wo.weight'''],
                      F'''model.layers.{layer_i}.mlp.gate_proj.weight''': loaded[F'''layers.{layer_i}.feed_forward.w1.weight'''],
                      F'''model.layers.{layer_i}.mlp.down_proj.weight''': loaded[F'''layers.{layer_i}.feed_forward.w2.weight'''],
                      F'''model.layers.{layer_i}.mlp.up_proj.weight''': loaded[F'''layers.{layer_i}.feed_forward.w3.weight'''],
                      F'''model.layers.{layer_i}.input_layernorm.weight''': loaded[F'''layers.{layer_i}.attention_norm.weight'''],
                      F'''model.layers.{layer_i}.post_attention_layernorm.weight''': loaded[F'''layers.{layer_i}.ffn_norm.weight'''],
                  }
            else:
                  # Sharded
                  # Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share
                  # the same storage object, saving attention_norm and ffn_norm will save other weights too, which is
                  # redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned.

                  UpperCAmelCase          =	{
                      F'''model.layers.{layer_i}.input_layernorm.weight''': loaded[0][
                          F'''layers.{layer_i}.attention_norm.weight'''
                      ].clone(),
                      F'''model.layers.{layer_i}.post_attention_layernorm.weight''': loaded[0][
                          F'''layers.{layer_i}.ffn_norm.weight'''
                      ].clone(),
                  }
                  UpperCAmelCase          =	permute(
                      torch.cat(
                          [
                              loaded[i][F'''layers.{layer_i}.attention.wq.weight'''].view(_snake_case				,	_snake_case				,	_snake_case							)
                              for i in range(_snake_case							)
                          ]				,	dim=0				,	).reshape(_snake_case				,	_snake_case							)							)
                  UpperCAmelCase          =	permute(
                      torch.cat(
                          [
                              loaded[i][F'''layers.{layer_i}.attention.wk.weight'''].view(
                                  _snake_case				,	_snake_case				,	_snake_case							)
                              for i in range(_snake_case							)
                          ]				,	dim=0				,	).reshape(_snake_case				,	_snake_case							)				,	_snake_case				,	_snake_case				,	_snake_case				,	)
                  UpperCAmelCase          =	torch.cat(
                      [
                          loaded[i][F'''layers.{layer_i}.attention.wv.weight'''].view(
                              _snake_case				,	_snake_case				,	_snake_case							)
                          for i in range(_snake_case							)
                      ]				,	dim=0				,	).reshape(_snake_case				,	_snake_case							)

                  UpperCAmelCase          =	torch.cat(
                      [loaded[i][F'''layers.{layer_i}.attention.wo.weight'''] for i in range(_snake_case							)]				,	dim=1							)
                  UpperCAmelCase          =	torch.cat(
                      [loaded[i][F'''layers.{layer_i}.feed_forward.w1.weight'''] for i in range(_snake_case							)]				,	dim=0							)
                  UpperCAmelCase          =	torch.cat(
                      [loaded[i][F'''layers.{layer_i}.feed_forward.w2.weight'''] for i in range(_snake_case							)]				,	dim=1							)
                  UpperCAmelCase          =	torch.cat(
                      [loaded[i][F'''layers.{layer_i}.feed_forward.w3.weight'''] for i in range(_snake_case							)]				,	dim=0							)

            UpperCAmelCase          =	inv_freq
            for k, v in state_dict.items():
                  UpperCAmelCase          =	filename
                  param_count += v.numel()
            torch.save(_snake_case				,	os.path.join(_snake_case				,	_snake_case							)							)

      UpperCAmelCase          =	F'''pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin'''
      if model_size == "7B":
            # Unsharded
            UpperCAmelCase          =	{
                """model.embed_tokens.weight""": loaded["""tok_embeddings.weight"""],
                """model.norm.weight""": loaded["""norm.weight"""],
                """lm_head.weight""": loaded["""output.weight"""],
            }
      else:
            UpperCAmelCase          =	{
                """model.norm.weight""": loaded[0]["""norm.weight"""],
                """model.embed_tokens.weight""": torch.cat(
                    [loaded[i]["""tok_embeddings.weight"""] for i in range(_snake_case							)]				,	dim=1							),
                """lm_head.weight""": torch.cat([loaded[i]["""output.weight"""] for i in range(_snake_case							)]				,	dim=0							),
            }

      for k, v in state_dict.items():
            UpperCAmelCase          =	filename
            param_count += v.numel()
      torch.save(_snake_case				,	os.path.join(_snake_case				,	_snake_case							)							)

      # Write configs
      UpperCAmelCase          =	{"""total_size""": param_count * 2}
      write_json(_snake_case				,	os.path.join(_snake_case				,	"""pytorch_model.bin.index.json"""							)							)
      UpperCAmelCase          =	params["""ffn_dim_multiplier"""] if """ffn_dim_multiplier""" in params else 1
      UpperCAmelCase          =	params["""multiple_of"""] if """multiple_of""" in params else 256
      UpperCAmelCase          =	LlamaConfig(
          hidden_size=_snake_case				,	intermediate_size=compute_intermediate_size(_snake_case				,	_snake_case				,	_snake_case							)				,	num_attention_heads=params["""n_heads"""]				,	num_hidden_layers=params["""n_layers"""]				,	rms_norm_eps=params["""norm_eps"""]				,	num_key_value_heads=_snake_case				,	)
      config.save_pretrained(_snake_case							)

      # Make space so we can load the model properly now.
      del state_dict
      del loaded
      gc.collect()

      print("""Loading the checkpoint in a Llama model."""							)
      UpperCAmelCase          =	LlamaForCausalLM.from_pretrained(_snake_case				,	torch_dtype=torch.floataa				,	low_cpu_mem_usage=_snake_case							)
      # Avoid saving this as part of the config.
      del model.config._name_or_path

      print("""Saving in the Transformers format."""							)
      model.save_pretrained(_snake_case				,	safe_serialization=_snake_case							)
      shutil.rmtree(_snake_case							)

def _a			(		_snake_case				,	_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
      print(F'''Saving a {tokenizer_class.__name__} to {tokenizer_path}.'''							)
      UpperCAmelCase          =	tokenizer_class(_snake_case							)
      tokenizer.save_pretrained(_snake_case							)

def _a			(		):







      """simple docstring"""






      UpperCAmelCase          =	argparse.ArgumentParser()
      parser.add_argument(
          """--input_dir"""				,	help="""Location of LLaMA weights, which contains tokenizer.model and model folders"""				,	)
      parser.add_argument(
          """--model_size"""				,	choices=["""7B""", """7Bf""", """13B""", """13Bf""", """30B""", """65B""", """70B""", """70Bf""", """tokenizer_only"""]				,	)
      parser.add_argument(
          """--output_dir"""				,	help="""Location to write HF model and tokenizer"""				,	)
      parser.add_argument("""--safe_serialization"""				,	type=_snake_case				,	help="""Whether or not to save using `safetensors`."""							)
      UpperCAmelCase          =	parser.parse_args()
      if args.model_size != "tokenizer_only":
            write_model(
                model_path=args.output_dir				,	input_base_path=os.path.join(args.input_dir				,	args.model_size							)				,	model_size=args.model_size				,	safe_serialization=args.safe_serialization				,	)
      UpperCAmelCase          =	os.path.join(args.input_dir				,	"""tokenizer.model"""							)
      write_tokenizer(args.output_dir				,	_snake_case							)


if __name__ == "__main__":
  main()



