

import argparse
import json
import os
from collections import OrderedDict

import numpy as np
import tensorflow as tf
import torch





def     _UpperCamelCase     (a__   :int       ):






							"""simple docstring"""





							UpperCamelCase__				     =			os.path.join(args.tf_model_dir   ,			"""parameters.json"""       )
							UpperCamelCase__				     =			json.loads(open(snake_case_       ).read()       )
							if not params:
														raise ValueError(
														    f"""It seems that the json file at {parameter_file} is empty. Make sure you have a correct json file."""       )
							if not args.output.endswith(""".pt"""       ):
														UpperCamelCase__				     =			args.output + """.pt"""
							UpperCamelCase__				     =			OrderedDict()
							with tf.device("""/CPU:0"""       ):
														UpperCamelCase__				     =			tf.train.load_checkpoint(args.tf_model_dir       )
														UpperCamelCase__				     =			reader.get_variable_to_shape_map()
														for key_name in shapes.keys():
																					UpperCamelCase__				     =			reader.get_tensor(snake_case_       ).astype(np.floataa       )
																					if key_name.endswith("""/adam_m"""       ) or key_name.endswith("""/adam_v"""       ):
																												continue
																					if key_name.startswith("""pasts/"""       ):
																												if key_name.startswith("""pasts/mlp"""       ):
																																			UpperCamelCase__				     =			int(key_name[9]       )
																												elif key_name.startswith("""pasts/out"""       ):
																																			UpperCamelCase__				     =			8
																												UpperCamelCase__				     =			"""model.sqout.%d.weight""" % (player * 2)  # enter to nn.Sequencial with Tanh, so 2 at a time
																												UpperCamelCase__				     =			vnp.transpose([1, 0]       ).copy()  # Mesh-Tensorflow is a diagonal matrix
																												UpperCamelCase__				     =			torch.tensor(snake_case_       )
																					elif key_name.startswith("""model/moe"""       ):
																												UpperCamelCase__				     =			int(key_name[9:].split("""/"""       )[0]       )
																												if key_name.endswith("""/switch_gating/kernel"""       ):
																																			UpperCamelCase__				     =			"""model.blocks.%d.feed_forward.mlp.router.classifier.weight""" % player
																																			UpperCamelCase__				     =			vnp.transpose([1, 0]       ).copy()  # Mesh-Tensorflow is a diagonal matrix
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																												elif key_name.endswith("""/softmlp/kernel"""       ):
																																			UpperCamelCase__				     =			"""model.blocks.%d.feed_forward.soft_bypass_mlp.weight""" % player
																																			UpperCamelCase__				     =			vnp.transpose([1, 0]       ).copy()  # Mesh-Tensorflow is a diagonal matrix
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																												elif key_name.endswith("""/wo/kernel"""       ) or key_name.endswith("""/wi/kernel"""       ):
																																			UpperCamelCase__				     =			key_name[-9:-7]
																																			for i in range(16       ):
																																										UpperCamelCase__				     =			"""model.blocks.%d.feed_forward.mlp.experts.expert_%d.%s.weight""" % (player, i, nlayer)
																																										UpperCamelCase__				     =			(
																																										    vnp[i].transpose([1, 0]       ).copy()
																																										)  # In Mesh-Tensorflow, it is one array, so it is divided
																																										UpperCamelCase__				     =			torch.tensor(snake_case_       )
																					elif key_name.startswith("""model/mlp"""       ):
																												UpperCamelCase__				     =			int(key_name[9:].split("""/"""       )[0]       )
																												if key_name.endswith("""/p1/kernel"""       ):
																																			UpperCamelCase__				     =			"""model.blocks.%d.feed_forward.mlp.wi.weight""" % player
																																			UpperCamelCase__				     =			vnp.transpose([1, 0]       ).copy()  # Mesh-Tensorflow is a diagonal matrix
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																												elif key_name.endswith("""/p1/bias"""       ):
																																			UpperCamelCase__				     =			"""model.blocks.%d.feed_forward.mlp.wi.bias""" % player
																																			UpperCamelCase__				     =			vnp.copy()  # same because it is one dimensional
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																												elif key_name.endswith("""/p2/kernel"""       ):
																																			UpperCamelCase__				     =			"""model.blocks.%d.feed_forward.mlp.wo.weight""" % player
																																			UpperCamelCase__				     =			vnp.transpose([1, 0]       ).copy()  # Mesh-Tensorflow is a diagonal matrix
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																												elif key_name.endswith("""/p2/bias"""       ):
																																			UpperCamelCase__				     =			"""model.blocks.%d.feed_forward.mlp.wo.bias""" % player
																																			UpperCamelCase__				     =			vnp.copy()  # same because it is one dimensional
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																					elif key_name.startswith("""model/ln"""       ):
																												UpperCamelCase__				     =			int(key_name[8:].split("""/"""       )[0]       )
																												if key_name.endswith("""/b"""       ):
																																			UpperCamelCase__				     =			"""model.blocks.%d.feed_forward.norm.bias""" % player
																																			UpperCamelCase__				     =			vnp.copy()  # same because it is one dimensional
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																												elif key_name.endswith("""/g"""       ):
																																			UpperCamelCase__				     =			"""model.blocks.%d.feed_forward.norm.weight""" % player
																																			UpperCamelCase__				     =			vnp.copy()  # same because it is one dimensional
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																					elif key_name.startswith("""model/att"""       ):
																												UpperCamelCase__				     =			int(key_name[9:].split("""/"""       )[0]       )
																												if key_name.endswith("""/qkv/kernel"""       ):
																																			UpperCamelCase__				     =			vnp.copy()  # Compute same dimension as Mesh-tensorflow using einsum
																																			UpperCamelCase__				     =			state[:, 0, :, :]
																																			UpperCamelCase__				     =			state[:, 1, :, :]
																																			UpperCamelCase__				     =			state[:, 2, :, :]
																																			UpperCamelCase__				     =			(
																																			    state_q.reshape([state_q.shape[0], state_q.shape[1] * state_q.shape[2]]       )
																																			    .transpose([1, 0]       )
																																			    .copy()
																																			)  # Mesh-Tensorflow is a diagonal matrix
																																			UpperCamelCase__				     =			(
																																			    state_k.reshape([state_k.shape[0], state_k.shape[1] * state_k.shape[2]]       )
																																			    .transpose([1, 0]       )
																																			    .copy()
																																			)  # Mesh-Tensorflow is a diagonal matrix
																																			UpperCamelCase__				     =			(
																																			    state_v.reshape([state_v.shape[0], state_v.shape[1] * state_v.shape[2]]       )
																																			    .transpose([1, 0]       )
																																			    .copy()
																																			)  # Mesh-Tensorflow is a diagonal matrix
																																			UpperCamelCase__				     =			"""model.blocks.%d.self_attn.self_attn.q_proj.weight""" % player
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																																			UpperCamelCase__				     =			"""model.blocks.%d.self_attn.self_attn.k_proj.weight""" % player
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																																			UpperCamelCase__				     =			"""model.blocks.%d.self_attn.self_attn.v_proj.weight""" % player
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																												elif key_name.endswith("""/o/kernel"""       ):
																																			UpperCamelCase__				     =			"""model.blocks.%d.self_attn.self_attn.out_proj.weight""" % player
																																			UpperCamelCase__				     =			(
																																			    vnp.reshape([vnp.shape[0] * vnp.shape[1], vnp.shape[2]]       ).transpose([1, 0]       ).copy()
																																			)  # Mesh-Tensorflow is a diagonal matrix
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																					elif key_name.startswith("""model/an"""       ):
																												UpperCamelCase__				     =			int(key_name[8:].split("""/"""       )[0]       )
																												if key_name.endswith("""/b"""       ):
																																			UpperCamelCase__				     =			"""model.blocks.%d.self_attn.norm.bias""" % player
																																			UpperCamelCase__				     =			vnp.copy()  # same because it is one dimensional
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																												elif key_name.endswith("""/g"""       ):
																																			UpperCamelCase__				     =			"""model.blocks.%d.self_attn.norm.weight""" % player
																																			UpperCamelCase__				     =			vnp.copy()  # same because it is one dimensional
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																					elif (
																					    key_name.startswith("""model/wte"""       )
																					    or key_name.startswith("""model/wpe"""       )
																					    or key_name.startswith("""model/ete"""       )
																					):
																												UpperCamelCase__				     =			{"""wte""": """embed_tokens""", """wpe""": """position_embeddings""", """ete""": """extra_position_embeddings"""}[
																												    key_name[-3:]
																												]
																												UpperCamelCase__				     =			"""model.%s.weight""" % nlayer
																												UpperCamelCase__				     =			vnp.copy()  # same in embedded
																												UpperCamelCase__				     =			torch.tensor(snake_case_       )
																												if key_name.startswith("""model/wte"""       ):
																																			UpperCamelCase__				     =			"""lm_head.weight"""
																																			UpperCamelCase__				     =			vnp.copy()  # same in embedded
																																			UpperCamelCase__				     =			torch.tensor(snake_case_       )
																					elif key_name.startswith("""model/wob"""       ):
																												UpperCamelCase__				     =			"""final_logits_bias"""
																												UpperCamelCase__				     =			vnp.copy()  # same in embedded
																												UpperCamelCase__				     =			state.reshape((1, -1)       )
																												UpperCamelCase__				     =			torch.tensor(snake_case_       )
																					elif key_name == "model/dense/kernel":
																												UpperCamelCase__				     =			"""model.last_project.weight"""
																												UpperCamelCase__				     =			vnp.transpose([1, 0]       ).copy()  # Mesh-Tensorflow is a diagonal matrix
																												UpperCamelCase__				     =			torch.tensor(snake_case_       )
																					elif key_name == "model/dense_1/bias":
																												UpperCamelCase__				     =			"""model.last_project.bias"""
																												UpperCamelCase__				     =			vnp.copy()  # same because it is one dimensional
																												UpperCamelCase__				     =			torch.tensor(snake_case_       )
							torch.save(snake_case_   ,			args.output       )


if __name__ == "__main__":
					UpperCamelCase__											= argparse.ArgumentParser(
					    description="model converter.", formatter_class=argparse.ArgumentDefaultsHelpFormatter
					)
					parser.add_argument("--tf_model_dir", metavar="PATH", type=str, required=True, help="import model")
					parser.add_argument("--output", metavar="PATH", type=str, required=True, help="output model")
					UpperCamelCase__											= parser.parse_args()
					convert_tf_gptsan_to_pt(args)











import argparse
import datetime





def     _UpperCamelCase     (a__   :str       ):






							"""simple docstring"""





							UpperCamelCase__				     =			{
							    """0""": """Sunday""",
							    """1""": """Monday""",
							    """2""": """Tuesday""",
							    """3""": """Wednesday""",
							    """4""": """Thursday""",
							    """5""": """Friday""",
							    """6""": """Saturday""",
							}

							UpperCamelCase__				     =			{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

							# Validate
							if not 0 < len(a__       ) < 11:
														raise ValueError("""Must be 10 characters long"""       )

							# Get month
							UpperCamelCase__				     =			int(date_input[0] + date_input[1]       )
							# Validate
							if not 0 < m < 13:
														raise ValueError("""Month must be between 1 - 12"""       )

							UpperCamelCase__				     =			date_input[2]
							# Validate
							if sep_a not in ["-", "/"]:
														raise ValueError("""Date separator must be '-' or '/'"""       )

							# Get day
							UpperCamelCase__				     =			int(date_input[3] + date_input[4]       )
							# Validate
							if not 0 < d < 32:
														raise ValueError("""Date must be between 1 - 31"""       )

							# Get second separator
							UpperCamelCase__				     =			date_input[5]
							# Validate
							if sep_a not in ["-", "/"]:
														raise ValueError("""Date separator must be '-' or '/'"""       )

							# Get year
							UpperCamelCase__				     =			int(date_input[6] + date_input[7] + date_input[8] + date_input[9]       )
							# Arbitrary year range
							if not 45 < y < 8500:
														raise ValueError(
														    """Year out of range. There has to be some sort of limit...right?"""       )

							# Get datetime obj for validation
							UpperCamelCase__				     =			datetime.date(int(a__       )   ,			int(a__       )   ,			int(a__       )       )

							# Start math
							if m <= 2:
														UpperCamelCase__				     =			y - 1
														UpperCamelCase__				     =			m + 12
							# maths var
							UpperCamelCase__				     =			int(str(a__       )[:2]       )
							UpperCamelCase__				     =			int(str(a__       )[2:]       )
							UpperCamelCase__				     =			int(2.6 * m - 5.39       )
							UpperCamelCase__				     =			int(c / 4       )
							UpperCamelCase__				     =			int(k / 4       )
							UpperCamelCase__				     =			int(d + k       )
							UpperCamelCase__				     =			int(t + u + v + x       )
							UpperCamelCase__				     =			int(z - (2 * c)       )
							UpperCamelCase__				     =			round(w % 7       )
							# End math

							# Validate math
							if f != convert_datetime_days[dt_ck.weekday()]:
														raise AssertionError("""The date was evaluated incorrectly. Contact developer."""       )

							# Response
							UpperCamelCase__				     =			f"""Your date {date_input}, is a {days[str(a__       )]}!"""
							return response


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					UpperCamelCase__											= argparse.ArgumentParser(
					    description=(
					        "Find out what day of the week nearly any date is or was. Enter "
					        "date as a string in the mm-dd-yyyy or mm/dd/yyyy format"
					    )
					)
					parser.add_argument(
					    "date_input", type=str, help="Date as a string (mm-dd-yyyy or mm/dd/yyyy)"
					)
					UpperCamelCase__											= parser.parse_args()
					zeller(args.date_input)




