





'''simple docstring'''



def 				_lowerCAmelCase  (			lowerCamelCase_     :					str			):
			__lowercase			  =							[0 for i in range(len(lowerCamelCase_			)			)]

			# initialize interval's left pointer and right pointer
			__lowercase  ,						__lowercase			  =							0, 0

			for i in range(1						,    len(lowerCamelCase_			)			):
						# case when current index is inside the interval
						if i <= right_pointer:
									__lowercase			  =							min(right_pointer - i + 1						,    z_result[i - left_pointer]			)
									__lowercase			  =							min_edge

						while go_next(lowerCamelCase_						,    lowerCamelCase_						,    lowerCamelCase_			):
									z_result[i] += 1

						# if new index's result gives us more right interval,
						# we've to update left_pointer and right_pointer
						if i + z_result[i] - 1 > right_pointer:
									__lowercase  ,						__lowercase			  =							i, i + z_result[i] - 1

			return z_result




def 				_lowerCAmelCase  (			lowerCamelCase_     :					int						,    lowerCamelCase_     :					list[int]						,    lowerCamelCase_     :					str			):
			return i + z_result[i] < len(lowerCamelCase_			) and s[z_result[i]] == s[i + z_result[i]]




def 				_lowerCAmelCase  (			lowerCamelCase_     :					str						,    lowerCamelCase_     :					str			):
			__lowercase			  =							0
			# concatenate 'pattern' and 'input_str' and call z_function
			# with concatenated string
			__lowercase			  =							z_function(pattern + input_str			)

			for val in z_result:
						# if value is greater then length of the pattern string
						# that means this index is starting position of substring
						# which is equal to pattern string
						if val >= len(lowerCamelCase_			):
									answer += 1

			return answer


if __name__ == "__main__":
	import doctest

	doctest.testmod()












'''simple docstring'''



import argparse
import gc
import json
import os
import re

import torch
from huggingface_hub import hf_hub_download

from transformers import AutoModelForCausalLM, AutoTokenizer, PreTrainedTokenizerFast, RwkvConfig
from transformers.modeling_utils import WEIGHTS_INDEX_NAME, shard_checkpoint


_SCREAMING_SNAKE_CASE   =      {
    '''169M''': 1_2,
    '''430M''': 2_4,
    '''1B5''': 2_4,
    '''3B''': 3_2,
    '''7B''': 3_2,
    '''14B''': 4_0,
}

_SCREAMING_SNAKE_CASE   =      {
    '''169M''': 7_6_8,
    '''430M''': 1_0_2_4,
    '''1B5''': 2_0_4_8,
    '''3B''': 2_5_6_0,
    '''7B''': 4_0_9_6,
    '''14B''': 5_1_2_0,
}




def 				_lowerCAmelCase  (			lowerCamelCase_     :					Dict			):
			__lowercase			  =							list(state_dict.keys()			)
			for name in state_dict_keys:
						__lowercase			  =							state_dict.pop(lowerCamelCase_			)
						# emb -> embedding
						if name.startswith('''emb.'''			):
									__lowercase			  =							name.replace('''emb.'''						,    '''embeddings.'''			)
						# ln_0 -> pre_ln (only present at block 0)
						if name.startswith('''blocks.0.ln0'''			):
									__lowercase			  =							name.replace('''blocks.0.ln0'''						,    '''blocks.0.pre_ln'''			)
						# att -> attention
						__lowercase			  =							re.sub(r'''blocks\.(\d+)\.att'''						,    r'''blocks.\1.attention'''						,    lowerCamelCase_			)
						# ffn -> feed_forward
						__lowercase			  =							re.sub(r'''blocks\.(\d+)\.ffn'''						,    r'''blocks.\1.feed_forward'''						,    lowerCamelCase_			)
						# time_mix_k -> time_mix_key and reshape
						if name.endswith('''.time_mix_k'''			):
									__lowercase			  =							name.replace('''.time_mix_k'''						,    '''.time_mix_key'''			)
						# time_mix_v -> time_mix_value and reshape
						if name.endswith('''.time_mix_v'''			):
									__lowercase			  =							name.replace('''.time_mix_v'''						,    '''.time_mix_value'''			)
						# time_mix_r -> time_mix_key and reshape
						if name.endswith('''.time_mix_r'''			):
									__lowercase			  =							name.replace('''.time_mix_r'''						,    '''.time_mix_receptance'''			)

						if name != "head.weight":
									__lowercase			  =							'''rwkv.''' + name

						__lowercase			  =							weight
			return state_dict




def 				_lowerCAmelCase  (			lowerCamelCase_     :					Optional[int]						,    lowerCamelCase_     :					Union[str, Any]						,    lowerCamelCase_     :					List[str]						,    lowerCamelCase_     :					List[Any]=None						,    lowerCamelCase_     :					List[Any]=None						,    lowerCamelCase_     :					Any=False						,    lowerCamelCase_     :					int=None			):
			# 1. If possible, build the tokenizer.
			if tokenizer_file is None:
						print('''No `--tokenizer_file` provided, we will use the default tokenizer.'''			)
						__lowercase			  =							5_0_2_7_7
						__lowercase			  =							AutoTokenizer.from_pretrained('''EleutherAI/gpt-neox-20b'''			)
			else:
						__lowercase			  =							PreTrainedTokenizerFast(tokenizer_file=lowerCamelCase_			)
						__lowercase			  =							len(lowerCamelCase_			)
			tokenizer.save_pretrained(lowerCamelCase_			)

			# 2. Build the config
			__lowercase			  =							list(NUM_HIDDEN_LAYERS_MAPPING.keys()			)
			if size is None:
						# Try to infer size from the checkpoint name
						for candidate in possible_sizes:
									if candidate in checkpoint_file:
												__lowercase			  =							candidate
												break
						if size is None:
									raise ValueError('''Could not infer the size, please provide it with the `--size` argument.'''			)
			if size not in possible_sizes:
						raise ValueError(f"`size` should be one of {possible_sizes}, got {size}."			)

			__lowercase			  =							RwkvConfig(
			    vocab_size=lowerCamelCase_						,    num_hidden_layers=NUM_HIDDEN_LAYERS_MAPPING[size]						,    hidden_size=HIDEN_SIZE_MAPPING[size]						,    )
			config.save_pretrained(lowerCamelCase_			)

			# 3. Download model file then convert state_dict
			__lowercase			  =							hf_hub_download(lowerCamelCase_						,    lowerCamelCase_			)
			__lowercase			  =							torch.load(lowerCamelCase_						,    map_location='''cpu'''			)
			__lowercase			  =							convert_state_dict(lowerCamelCase_			)

			# 4. Split in shards and save
			__lowercase  ,						__lowercase			  =							shard_checkpoint(lowerCamelCase_			)
			for shard_file, shard in shards.items():
						torch.save(lowerCamelCase_						,    os.path.join(lowerCamelCase_						,    lowerCamelCase_			)			)

			if index is not None:
						__lowercase			  =							os.path.join(lowerCamelCase_						,    lowerCamelCase_			)
						# Save the index as well
						with open(lowerCamelCase_						,    '''w'''						,    encoding='''utf-8'''			) as f:
									__lowercase			  =							json.dumps(lowerCamelCase_						,    indent=2						,    sort_keys=lowerCamelCase_			) + '''\n'''
									f.write(lowerCamelCase_			)

						# 5. Clean up shards (for some reason the file PyTorch saves take the same space as the whole state_dict
						print(
						    '''Cleaning up shards. This may error with an OOM error, it this is the case don\'t worry you still have converted the model.'''			)
						__lowercase			  =							list(shards.keys()			)

						del state_dict
						del shards
						gc.collect()

						for shard_file in shard_files:
									__lowercase			  =							torch.load(os.path.join(lowerCamelCase_						,    lowerCamelCase_			)			)
									torch.save({k: v.cpu().clone() for k, v in state_dict.items()}						,    os.path.join(lowerCamelCase_						,    lowerCamelCase_			)			)

			del state_dict
			gc.collect()

			if push_to_hub:
						if model_name is None:
									raise ValueError('''Please provide a `model_name` to push the model to the Hub.'''			)
						__lowercase			  =							AutoModelForCausalLM.from_pretrained(lowerCamelCase_			)
						model.push_to_hub(lowerCamelCase_						,    max_shard_size='''2GB'''			)
						tokenizer.push_to_hub(lowerCamelCase_			)


if __name__ == "__main__":
	_SCREAMING_SNAKE_CASE   =      argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '''--repo_id''', default=None, type=str, required=True, help='''Repo ID from which to pull the checkpoint.'''
	)
	parser.add_argument(
	    '''--checkpoint_file''', default=None, type=str, required=True, help='''Name of the checkpoint file in the repo.'''
	)
	parser.add_argument(
	    '''--output_dir''', default=None, type=str, required=True, help='''Where to save the converted model.'''
	)
	parser.add_argument(
	    '''--tokenizer_file''',
	    default=None,
	    type=str,
	    help='''Path to the tokenizer file to use (if not provided, only the model is converted).''',
	)
	parser.add_argument(
	    '''--size''',
	    default=None,
	    type=str,
	    help='''Size of the model. Will be inferred from the `checkpoint_file` if not passed.''',
	)
	parser.add_argument(
	    '''--push_to_hub''',
	    action='''store_true''',
	    help='''Push to the Hub the converted model.''',
	)
	parser.add_argument(
	    '''--model_name''',
	    default=None,
	    type=str,
	    help='''Name of the pushed model on the Hub, including the username / organization.''',
	)

	_SCREAMING_SNAKE_CASE   =      parser.parse_args()
	convert_rmkv_checkpoint_to_hf_format(
	    args.repo_id,
	    args.checkpoint_file,
	    args.output_dir,
	    size=args.size,
	    tokenizer_file=args.tokenizer_file,
	    push_to_hub=args.push_to_hub,
	    model_name=args.model_name,
	)





