'''simple docstring'''

import argparse
import os
import re
import zipfile

import torch

from transformers import AutoTokenizer, GPTaConfig







def      UpperCamelCase_						(					snake_case_       :       Union[str, Any]						,		snake_case_       :       List[str]						,		snake_case_       :       Optional[Any]=0      )					->     Tuple:






 '''simple docstring'''

 if name is None:
  __lowerCAmelCase											=						None
 else:
  __lowerCAmelCase											=						'.' * max(0						,		spaces - 2      ) + '# {:' + str(50 - spaces      ) + 's}'
  __lowerCAmelCase											=						fmt.format(_UpperCAmelCase      )

 # Print and recurse (if needed).
 if isinstance(_UpperCAmelCase						,		_UpperCAmelCase      ):
  if msg is not None:
   print(_UpperCAmelCase      )
  for k in val.keys():
   recursive_print(_UpperCAmelCase						,		val[k]						,		spaces + 2      )
 elif isinstance(_UpperCAmelCase						,		torch.Tensor      ):
  print(_UpperCAmelCase						,		""":"""						,		val.size()      )
 else:
  print(_UpperCAmelCase						,		""":"""						,		_UpperCAmelCase      )







def      UpperCamelCase_						(					snake_case_       :       int						,		snake_case_       :       Union[str, Any]						,		snake_case_       :       Dict						,		snake_case_       :       Optional[Any]						,		snake_case_       :       Optional[int]      )					->     str:






 '''simple docstring'''

 __lowerCAmelCase											=						param.size()
 if checkpoint_version == 1.0:
  # version 1.0 stores [num_heads * hidden_size * num_splits, :]
  __lowerCAmelCase											=						(num_heads, hidden_size, num_splits) + input_shape[1:]
  __lowerCAmelCase											=						param.view(*_UpperCAmelCase      )
  __lowerCAmelCase											=						param.transpose(0						,		2      )
  __lowerCAmelCase											=						param.transpose(1						,		2      ).contiguous()
 elif checkpoint_version >= 2.0:
  # other versions store [num_heads * num_splits * hidden_size, :]
  __lowerCAmelCase											=						(num_heads, num_splits, hidden_size) + input_shape[1:]
  __lowerCAmelCase											=						param.view(*_UpperCAmelCase      )
  __lowerCAmelCase											=						param.transpose(0						,		1      ).contiguous()
 __lowerCAmelCase											=						param.view(*_UpperCAmelCase      )
 return param







def      UpperCamelCase_						(					snake_case_       :       int						,		snake_case_       :       Any						,		snake_case_       :       Tuple      )					->     Tuple:






 '''simple docstring'''

 __lowerCAmelCase											=						{}

 # old versions did not store training args
 __lowerCAmelCase											=						input_state_dict.get("""args"""						,		_UpperCAmelCase      )
 if ds_args is not None:
  # do not make the user write a config file when the exact dimensions/sizes are already in the checkpoint
  # from pprint import pprint
  # pprint(vars(ds_args))

  __lowerCAmelCase											=						ds_args.padded_vocab_size
  __lowerCAmelCase											=						ds_args.max_position_embeddings
  __lowerCAmelCase											=						ds_args.hidden_size
  __lowerCAmelCase											=						ds_args.num_layers
  __lowerCAmelCase											=						ds_args.num_attention_heads
  __lowerCAmelCase											=						ds_args.ffn_hidden_size
  # pprint(config)

 # The number of heads.
 __lowerCAmelCase											=						config.n_head
 # The hidden_size per head.
 __lowerCAmelCase											=						config.n_embd // config.n_head
 # Megatron-LM checkpoint version
 if "checkpoint_version" in input_state_dict.keys():
  __lowerCAmelCase											=						input_state_dict['checkpoint_version']
 else:
  __lowerCAmelCase											=						0.0

 # The model.
 __lowerCAmelCase											=						input_state_dict['model']
 # The language model.
 __lowerCAmelCase											=						model['language_model']
 # The embeddings.
 __lowerCAmelCase											=						lm['embedding']

 # The word embeddings.
 __lowerCAmelCase											=						embeddings['word_embeddings']['weight']
 # Truncate the embedding table to vocab_size rows.
 __lowerCAmelCase											=						word_embeddings[: config.vocab_size, :]
 __lowerCAmelCase											=						word_embeddings

 # The position embeddings.
 __lowerCAmelCase											=						embeddings['position_embeddings']['weight']
 # Read the causal mask dimension (seqlen). [max_sequence_length, hidden_size]
 __lowerCAmelCase											=						pos_embeddings.size(0      )
 if n_positions != config.n_positions:
  raise ValueError(
      f"""pos_embeddings.max_sequence_length={n_positions} and config.n_positions={config.n_positions} don't match"""      )
 # Store the position embeddings.
 __lowerCAmelCase											=						pos_embeddings

 # The transformer.
 __lowerCAmelCase											=						lm['transformer'] if 'transformer' in lm.keys() else lm['encoder']

 # The regex to extract layer names.
 __lowerCAmelCase											=						re.compile(r"""layers\.(\d+)\.([a-z0-9_.]+)\.([a-z]+)"""      )

 # The simple map of names for "automated" rules.
 __lowerCAmelCase											=						{
     'attention.dense': '.attn.c_proj.',
     'self_attention.dense': '.attn.c_proj.',
     'mlp.dense_h_to_4h': '.mlp.c_fc.',
     'mlp.dense_4h_to_h': '.mlp.c_proj.',
 }

 # Extract the layers.
 for key, val in transformer.items():
  # Match the name.
  __lowerCAmelCase											=						layer_re.match(_UpperCAmelCase      )

  # Stop if that's not a layer
  if m is None:
   break

  # The index of the layer.
  __lowerCAmelCase											=						int(m.group(1      )      )
  # The name of the operation.
  __lowerCAmelCase											=						m.group(2      )
  # Is it a weight or a bias?
  __lowerCAmelCase											=						m.group(3      )

  # The name of the layer.
  __lowerCAmelCase											=						f"""transformer.h.{layer_idx}"""

  # For layernorm(s), simply store the layer norm.
  if op_name.endswith("""layernorm"""      ):
   __lowerCAmelCase											=						'ln_1' if op_name.startswith("""input"""      ) else 'ln_2'
   __lowerCAmelCase											=						val

  # Transpose the QKV matrix.
  elif (
      op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
  ) and weight_or_bias == "weight":
   # Insert a tensor of 1x1xDxD bias.
   __lowerCAmelCase											=						torch.tril(torch.ones((n_positions, n_positions)						,		dtype=torch.floataa      )      ).view(
       1						,		1						,		_UpperCAmelCase						,		_UpperCAmelCase      )
   __lowerCAmelCase											=						causal_mask

   # Insert a "dummy" tensor for masked_bias.
   __lowerCAmelCase											=						torch.tensor(-1E4						,		dtype=torch.floataa      )
   __lowerCAmelCase											=						masked_bias

   __lowerCAmelCase											=						fix_query_key_value_ordering(_UpperCAmelCase						,		_UpperCAmelCase						,		3						,		_UpperCAmelCase						,		_UpperCAmelCase      )
   # Megatron stores (3*D) x D but transformers-GPT2 expects D x 3*D.
   __lowerCAmelCase											=						out_val.transpose(0						,		1      ).contiguous()
   # Store.
   __lowerCAmelCase											=						out_val

  # Transpose the bias.
  elif (
      op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
  ) and weight_or_bias == "bias":
   __lowerCAmelCase											=						fix_query_key_value_ordering(_UpperCAmelCase						,		_UpperCAmelCase						,		3						,		_UpperCAmelCase						,		_UpperCAmelCase      )
   # Store. No change of shape.
   __lowerCAmelCase											=						out_val

  # Transpose the weights.
  elif weight_or_bias == "weight":
   __lowerCAmelCase											=						megatron_to_transformers[op_name]
   __lowerCAmelCase											=						val.transpose(0						,		1      )

  # Copy the bias.
  elif weight_or_bias == "bias":
   __lowerCAmelCase											=						megatron_to_transformers[op_name]
   __lowerCAmelCase											=						val

  # DEBUG.
 assert config.n_layer == layer_idx + 1

 # The final layernorm.
 __lowerCAmelCase											=						transformer['final_layernorm.weight']
 __lowerCAmelCase											=						transformer['final_layernorm.bias']

 # For LM head, transformers' wants the matrix to weight embeddings.
 __lowerCAmelCase											=						word_embeddings

 # It should be done!
 return output_state_dict







def      UpperCamelCase_						(					)					->     int:






 '''simple docstring'''

 __lowerCAmelCase											=						argparse.ArgumentParser()
 parser.add_argument("""--print-checkpoint-structure"""						,		action="""store_true"""      )
 parser.add_argument(
     """path_to_checkpoint"""						,		type=_UpperCAmelCase						,		help="""Path to the checkpoint file (.zip archive or direct .pt file)"""						,		)
 parser.add_argument(
     """--config_file"""						,		default=""""""						,		type=_UpperCAmelCase						,		help="""An optional config json file describing the pre-trained model."""						,		)
 __lowerCAmelCase											=						parser.parse_args()

 # Extract the basename.
 __lowerCAmelCase											=						os.path.dirname(args.path_to_checkpoint      )

 # Load the model.
 # the .zip is very optional, let's keep it for backward compatibility
 print(f"""Extracting PyTorch state dictionary from {args.path_to_checkpoint}"""      )
 if args.path_to_checkpoint.endswith(""".zip"""      ):
  with zipfile.ZipFile(args.path_to_checkpoint						,		"""r"""      ) as checkpoint:
   with checkpoint.open("""release/mp_rank_00/model_optim_rng.pt"""      ) as pytorch_dict:
    __lowerCAmelCase											=						torch.load(_UpperCAmelCase						,		map_location="""cpu"""      )
 else:
  __lowerCAmelCase											=						torch.load(args.path_to_checkpoint						,		map_location="""cpu"""      )

 __lowerCAmelCase											=						input_state_dict.get("""args"""						,		_UpperCAmelCase      )

 # Read the config, or default to the model released by NVIDIA.
 if args.config_file == "":
  if ds_args is not None:
   if ds_args.bias_gelu_fusion:
    __lowerCAmelCase											=						'gelu_fast'
   elif ds_args.openai_gelu:
    __lowerCAmelCase											=						'gelu_new'
   else:
    __lowerCAmelCase											=						'gelu'
  else:
   # in the very early days this used to be "gelu_new"
   __lowerCAmelCase											=						'gelu_new'

  # Spell out all parameters in case the defaults change.
  __lowerCAmelCase											=						GPTaConfig(
      vocab_size=5_02_57						,		n_positions=10_24						,		n_embd=10_24						,		n_layer=24						,		n_head=16						,		n_inner=40_96						,		activation_function=_UpperCAmelCase						,		resid_pdrop=0.1						,		embd_pdrop=0.1						,		attn_pdrop=0.1						,		layer_norm_epsilon=1E-5						,		initializer_range=0.0_2						,		summary_type="""cls_index"""						,		summary_use_proj=_UpperCAmelCase						,		summary_activation=_UpperCAmelCase						,		summary_proj_to_labels=_UpperCAmelCase						,		summary_first_dropout=0.1						,		scale_attn_weights=_UpperCAmelCase						,		use_cache=_UpperCAmelCase						,		bos_token_id=5_02_56						,		eos_token_id=5_02_56						,		)
 else:
  __lowerCAmelCase											=						GPTaConfig.from_json_file(args.config_file      )

 __lowerCAmelCase											=						['GPT2LMHeadModel']

 # Convert.
 print("""Converting"""      )
 __lowerCAmelCase											=						convert_megatron_checkpoint(_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase      )

 # Print the structure of converted state dict.
 if args.print_checkpoint_structure:
  recursive_print(_UpperCAmelCase						,		_UpperCAmelCase      )

 # Add tokenizer class info to config
 # see https://github.com/huggingface/transformers/issues/13906)
 if ds_args is not None:
  __lowerCAmelCase											=						ds_args.tokenizer_type
  if tokenizer_type == "GPT2BPETokenizer":
   __lowerCAmelCase											=						'gpt2'
  elif tokenizer_type == "PretrainedFromHF":
   __lowerCAmelCase											=						ds_args.tokenizer_name_or_path
  else:
   raise ValueError(f"""Unrecognized tokenizer_type {tokenizer_type}"""      )
 else:
  __lowerCAmelCase											=						'gpt2'

 __lowerCAmelCase											=						AutoTokenizer.from_pretrained(_UpperCAmelCase      )
 __lowerCAmelCase											=						type(_UpperCAmelCase      ).__name__
 __lowerCAmelCase											=						tokenizer_class

 # Store the config to file.
 print("""Saving config"""      )
 config.save_pretrained(_UpperCAmelCase      )

 # Save tokenizer based on args
 print(f"""Adding {tokenizer_class} tokenizer files"""      )
 tokenizer.save_pretrained(_UpperCAmelCase      )

 # Store the state_dict to file.
 __lowerCAmelCase											=						os.path.join(_UpperCAmelCase						,		"""pytorch_model.bin"""      )
 print(f"""Saving checkpoint to \"{output_checkpoint_file}\""""      )
 torch.save(_UpperCAmelCase						,		_UpperCAmelCase      )


####################################################################################################

if __name__ == "__main__":
 main()

####################################################################################################













"""simple docstring"""




import qiskit





def 						UpperCAmelCase__		(     _UpperCAmelCase ,					_UpperCAmelCase					):






  """simple docstring"""





  A_  :       Tuple										=  qiskit.Aer.get_backend('aer_simulator'					)

  A_  :       str										=  qiskit.QuantumCircuit(4 ,					2					)
  # encode inputs in qubits 0 and 1
  if bita == 1:
    qc_ha.x(0					)
  if bita == 1:
    qc_ha.x(1					)
  qc_ha.barrier()

  # use cnots to write XOR of the inputs on qubit2
  qc_ha.cx(0 ,					2					)
  qc_ha.cx(1 ,					2					)

  # use ccx / toffoli gate to write AND of the inputs on qubit3
  qc_ha.ccx(0 ,					1 ,					3					)
  qc_ha.barrier()

  # extract outputs
  qc_ha.measure(2 ,					0					)  # extract XOR value
  qc_ha.measure(3 ,					1					)  # extract AND value

  # Execute the circuit on the qasm simulator
  A_  :       Optional[Any]										=  qiskit.execute(_UpperCAmelCase ,					_UpperCAmelCase ,					shots=1000					)

  # Return the histogram data of the results of the experiment
  return job.result().get_counts(_UpperCAmelCase					)


if __name__ == "__main__":
   lowerCamelCase_     :						List[str]						=					half_adder(1, 1)
   print(F"Half Adder Output Qubit Counts: {counts}")