


from scipy.stats import spearmanr

import datasets


SCREAMING_SNAKE_CASE__     					=			"\nThe Spearman rank-order correlation coefficient is a measure of the\nrelationship between two datasets. Like other correlation coefficients,\nthis one varies between -1 and +1 with 0 implying no correlation.\nPositive correlations imply that as data in dataset x increases, so\ndoes data in dataset y. Negative correlations imply that as x increases,\ny decreases. Correlations of -1 or +1 imply an exact monotonic relationship.\n\nUnlike the Pearson correlation, the Spearman correlation does not\nassume that both datasets are normally distributed.\n\nThe p-value roughly indicates the probability of an uncorrelated system\nproducing datasets that have a Spearman correlation at least as extreme\nas the one computed from these datasets. The p-values are not entirely\nreliable but are probably reasonable for datasets larger than 500 or so.\n"

SCREAMING_SNAKE_CASE__     					=			"\nArgs:\n    predictions (`List[float]`): Predicted labels, as returned by a model.\n    references (`List[float]`): Ground truth labels.\n    return_pvalue (`bool`): If `True`, returns the p-value. If `False`, returns\n            only the spearmanr score. Defaults to `False`.\nReturns:\n    spearmanr (`float`): Spearman correlation coefficient.\n    p-value (`float`): p-value. **Note**: is only returned if `return_pvalue=True` is input.\nExamples:\n    Example 1:\n        >>> spearmanr_metric = datasets.load_metric(\"spearmanr\")\n        >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5], predictions=[10, 9, 2.5, 6, 4])\n        >>> print(results)\n        {'spearmanr': -0.7}\n\n    Example 2:\n        >>> spearmanr_metric = datasets.load_metric(\"spearmanr\")\n        >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5],\n        ...                                     predictions=[10, 9, 2.5, 6, 4],\n        ...                                     return_pvalue=True)\n        >>> print(results['spearmanr'])\n        -0.7\n        >>> print(round(results['spearmanr_pvalue'], 2))\n        0.19\n"

SCREAMING_SNAKE_CASE__     					=			R"\\n@book{kokoska2000crc,\n  title={CRC standard probability and statistics tables and formulae},\n  author={Kokoska, Stephen and Zwillinger, Daniel},\n  year={2000},\n  publisher={Crc Press}\n}\n@article{2020SciPy-NMeth,\n  author  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and\n            Haberland, Matt and Reddy, Tyler and Cournapeau, David and\n            Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and\n            Bright, Jonathan and {van der Walt}, St{\'e}fan J. and\n            Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and\n            Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and\n            Kern, Robert and Larson, Eric and Carey, C J and\n            Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and\n            {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and\n            Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and\n            Harris, Charles R. and Archibald, Anne M. and\n            Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and\n            {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},\n  title   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific\n            Computing in Python}},\n  journal = {Nature Methods},\n  year    = {2020},\n  volume  = {17},\n  pages   = {261--272},\n  adsurl  = {https://rdcu.be/b08Wh},\n  doi     = {10.1038/s41592-019-0686-2},\n}\n"



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION		,		_KWARGS_DESCRIPTION							)
class 						_UpperCAmelCase      (     datasets.Metric							):






		def _snake_case		(						self				:     str):
				return datasets.MetricInfo(
				    description=_DESCRIPTION   ,  citation=_CITATION   ,  inputs_description=_KWARGS_DESCRIPTION   ,  features=datasets.Features(
				        {
				            "predictions": datasets.Value("float"),
				            "references": datasets.Value("float"),
				        })   ,  reference_urls=["https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.spearmanr.html"]   ,  )







		def _snake_case		(						self				:     Dict   ,  UpperCAmelCase				:     Dict   ,  UpperCAmelCase				:     Union[str, Any]   ,  UpperCAmelCase				:     Tuple=False):
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						spearmanr(UpperCAmelCase   ,  UpperCAmelCase)
				if return_pvalue:
						return {"spearmanr": results[0], "spearmanr_pvalue": results[1]}
				else:
						return {"spearmanr": results[0]}










import argparse
import json
import os

import tensorstore as ts
import torch
from flax import serialization
from flax.traverse_util import flatten_dict, unflatten_dict
from tensorflow.io import gfile

from transformers.modeling_utils import dtype_byte_size
from transformers.models.switch_transformers.convert_switch_transformers_original_flax_checkpoint_to_pytorch import (
    rename_keys,
)
from transformers.utils import WEIGHTS_INDEX_NAME, WEIGHTS_NAME
from transformers.utils.hub import convert_file_size_to_int


def     lowercase	(    a     , a ):



		'''simple docstring'''




		if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 3:
				# expert layer
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						flax_key_tuple[:-1] + ("weight",)
				SCREAMING_SNAKE_CASE_				:Any				     =						torch.permute(a     , (0, 2, 1) )
		elif flax_key_tuple[-1] == "kernel" and ".".join(a ):
				# linear layer
				SCREAMING_SNAKE_CASE_				:str				     =						flax_key_tuple[:-1] + ("weight",)
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						flax_tensor.T
		elif flax_key_tuple[-1] in ["scale", "embedding"]:
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						flax_key_tuple[:-1] + ("weight",)

		return flax_key_tuple, flax_tensor


def     lowercase	(    a     , a     , a ):



		'''simple docstring'''




		if "metadata" in layer:
				SCREAMING_SNAKE_CASE_				:Dict				     =						layer.split("metadata" )
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						"".join(split_layer[0] )[:-1]
				SCREAMING_SNAKE_CASE_				:str				     =						[tuple(("metadata" + split_layer[1]).split("/" ) )]
		elif "kvstore" in layer:
				SCREAMING_SNAKE_CASE_				:str				     =						layer.split("kvstore" )
				SCREAMING_SNAKE_CASE_				:str				     =						"".join(split_layer[0] )[:-1]
				SCREAMING_SNAKE_CASE_				:str				     =						[tuple(("kvstore" + split_layer[1]).split("/" ) )]

		else:
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						layer.split("/" )
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						"/".join(split_layer[:-1] )
				SCREAMING_SNAKE_CASE_				:int				     =						(split_layer[-1],)

		if "kvstore/path" in layer:
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						F"{switch_checkpoint_path}/{checkpoint_info[layer]}"
		elif "kvstore/driver" in layer:
				SCREAMING_SNAKE_CASE_				:Tuple				     =						"file"
		else:
				SCREAMING_SNAKE_CASE_				:str				     =						checkpoint_info[layer]

		return curr_real_layer_name, split_layer, content


def     lowercase	(    a     , a ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:int				     =						rename_keys(a )
		SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						{}
		for k, v in current_block.items():
				SCREAMING_SNAKE_CASE_				:List[str]				     =						v
		SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						new_current_block
		torch.save(a     , a )


def     lowercase	(    a     , a     , a     , a     , a = WEIGHTS_NAME ):



		'''simple docstring'''




		SCREAMING_SNAKE_CASE_				:Optional[int]				     =						convert_file_size_to_int(a )
		SCREAMING_SNAKE_CASE_				:int				     =						[]
		SCREAMING_SNAKE_CASE_				:str				     =						{}
		SCREAMING_SNAKE_CASE_				:List[str]				     =						0
		SCREAMING_SNAKE_CASE_				:Optional[int]				     =						0

		os.makedirs(a     , exist_ok=a )
		with gfile.GFile(switch_checkpoint_path + "/checkpoint"     , "rb" ) as fp:
				SCREAMING_SNAKE_CASE_				:int				     =						serialization.msgpack_restore(fp.read() )["optimizer"]["target"]
				SCREAMING_SNAKE_CASE_				:Any				     =						flatten_dict(a     , sep="/" )

		SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						{}
		for layer in checkpoint_info.keys():
				SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_				:List[Any]				     =						get_key_and_tensorstore_dict(
				    a     , a     , a )
				if curr_real_layer_name in all_layers:
						SCREAMING_SNAKE_CASE_				:str				     =						content
				else:
						SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						{split_layer[-1]: content}

		for key in all_layers.keys():
				# open tensorstore file
				SCREAMING_SNAKE_CASE_				:Any				     =						ts.open(unflatten_dict(all_layers[key] ) ).result().read().result()
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						torch.tensor(a )
				SCREAMING_SNAKE_CASE_				:str				     =						raw_weights.numel() * dtype_byte_size(raw_weights.dtype )

				# use the renaming pattern from the small conversion scripts
				SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						rename_base_flax_keys(tuple(key.split("/" ) )     , a )
				SCREAMING_SNAKE_CASE_				:Any				     =						"/".join(a )

				# If this weight is going to tip up over the maximal size, we split.
				if current_block_size + weight_size > max_shard_size:
						SCREAMING_SNAKE_CASE_				:str				     =						os.path.join(
						    a     , weights_name.replace(".bin"     , F"-{len(a )+1:05d}-of-???.bin" ) )
						rename_and_save_block(a     , a )
						sharded_state_dicts.append(current_block.keys() )
						del current_block
						SCREAMING_SNAKE_CASE_				:Tuple				     =						{}
						SCREAMING_SNAKE_CASE_				:Dict				     =						0

				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						raw_weights.to(getattr(a     , a ) )
				current_block_size += weight_size
				total_size += weight_size

		# Add the last block
		SCREAMING_SNAKE_CASE_				:Dict				     =						os.path.join(a     , weights_name.replace(".bin"     , F"-{len(a )+1:05d}-of-???.bin" ) )
		rename_and_save_block(a     , a )
		sharded_state_dicts.append(current_block.keys() )

		# If we only have one shard, we return it
		if len(a ) == 1:
				return {weights_name: sharded_state_dicts[0]}, None

		# Otherwise, let's build the index
		SCREAMING_SNAKE_CASE_				:Optional[int]				     =						{}
		SCREAMING_SNAKE_CASE_				:int				     =						{}
		for idx, shard in enumerate(a ):
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						weights_name.replace(
				    ".bin"     , F"-{idx+1:05d}-of-{len(a ):05d}.bin" )  # len(sharded_state_dicts):05d}
				SCREAMING_SNAKE_CASE_				:Any				     =						os.path.join(a     , weights_name.replace(".bin"     , F"-{idx+1:05d}-of-???.bin" ) )
				os.rename(a     , os.path.join(a     , a ) )
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						shard
				for key in shard:
						SCREAMING_SNAKE_CASE_				:str				     =						shard_file

    # Add the metadata
		SCREAMING_SNAKE_CASE_				:List[str]				     =						{"total_size": total_size}
		SCREAMING_SNAKE_CASE_				:Optional[int]				     =						{"metadata": metadata, "weight_map": weight_map}

		with open(os.path.join(a     , a )     , "w"     , encoding="utf-8" ) as f:
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						json.dumps(a     , indent=2     , sort_keys=a ) + "\n"
				f.write(a )

		return metadata, index


if __name__ == "__main__":
		SCREAMING_SNAKE_CASE__     					=			argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    "--switch_t5x_checkpoint_path",
		    default="/mnt/disks/disk_switch/original_checkpoints/switch-xxl-128/checkpoint_634600",
		    type=str,
		    required=False,
		    help="Path to a directory containing a folder per layer. Follows the original Google format.",
		)
		parser.add_argument("--max_shard_size", default="10GB", required=False, help="Max shard size")
		parser.add_argument("--dtype", default="bfloat16", type=str, required=False, help="dtype of the saved model")
		parser.add_argument(
		    "--pytorch_dump_folder_path",
		    default="/mnt/disks/disk_switch/original_checkpoints/switch-xxl-128-converted",
		    type=str,
		    required=False,
		    help="Path to the output pytorch model.",
		)
		SCREAMING_SNAKE_CASE__     					=			parser.parse_args()
		shard_on_the_fly(
		    args.switch_tax_checkpoint_path,
		    args.pytorch_dump_folder_path,
		    args.max_shard_size,
		    args.dtype,
		)


def     lowercase	(    ):



		'''simple docstring'''




		from transformers import SwitchTransformersConfig, SwitchTransformersForConditionalGeneration, TaTokenizer

		SCREAMING_SNAKE_CASE_				:Dict				     =						SwitchTransformersConfig.from_pretrained("google/switch-base-8" )
		config.save_pretrained("/home/arthur_huggingface_co/transformers/switch_converted" )
		SCREAMING_SNAKE_CASE_				:str				     =						SwitchTransformersForConditionalGeneration.from_pretrained(
		    "/home/arthur_huggingface_co/transformers/switch_converted"     , device_map="auto" )

		SCREAMING_SNAKE_CASE_				:List[Any]				     =						TaTokenizer.from_pretrained("t5-small" )
		SCREAMING_SNAKE_CASE_				:Optional[int]				     =						"A <extra_id_0> walks into a bar a orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>."

		SCREAMING_SNAKE_CASE_				:List[Any]				     =						tokenizer(a     , return_tensors="pt" ).input_ids
		SCREAMING_SNAKE_CASE_				:List[str]				     =						model.generate(a     , decoder_start_token_id=0 )
		print(tokenizer.decode(out[0] ) )






