


import argparse

import torch
from saprl.hub import distilhubert

from transformers import HubertConfig, HubertModel, WavaVecaFeatureExtractor, logging


logging.set_verbosity_info()
__UpperCamelCase      						=    logging.get_logger(__name__)

__UpperCamelCase      						=    {
    'post_extract_proj': 'feature_projection.projection',
    'encoder.pos_conv.0': 'encoder.pos_conv_embed.conv',
    'self_attn.k_proj': 'encoder.layers.*.attention.k_proj',
    'self_attn.v_proj': 'encoder.layers.*.attention.v_proj',
    'self_attn.q_proj': 'encoder.layers.*.attention.q_proj',
    'self_attn.out_proj': 'encoder.layers.*.attention.out_proj',
    'self_attn_layer_norm': 'encoder.layers.*.layer_norm',
    'fc1': 'encoder.layers.*.feed_forward.intermediate_dense',
    'fc2': 'encoder.layers.*.feed_forward.output_dense',
    'final_layer_norm': 'encoder.layers.*.final_layer_norm',
    'encoder.layer_norm': 'encoder.layer_norm',
    'mask_emb': 'masked_spec_embed',
}
def     UpperCamelCase_(			_A				:int			,       _A				:Dict			,       _A				:int			,       _A				:List[str]			,       _A				:Optional[int]					)->						Any:
			for attribute in key.split("."					):
						UpperCamelCase__   =    getattr(_A			,       _A					)

			if weight_type is not None:
						UpperCamelCase__   =    getattr(_A			,       _A					).shape
			else:
						UpperCamelCase__   =    hf_pointer.shape

			assert hf_shape == value.shape, (
			    F'''Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be'''
			    F''' {value.shape} for {full_name}'''
			)

			if weight_type == "weight":
						UpperCamelCase__   =    value
			elif weight_type == "weight_g":
						UpperCamelCase__   =    value
			elif weight_type == "weight_v":
						UpperCamelCase__   =    value
			elif weight_type == "bias":
						UpperCamelCase__   =    value
			else:
						UpperCamelCase__   =    value

			logger.info(F'''{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.'''					)
def     UpperCamelCase_(			_A				:Optional[Any]			,       _A				:Dict					)->						List[Any]:
			UpperCamelCase__   =    []
			UpperCamelCase__   =    fairseq_model.state_dict()

			UpperCamelCase__   =    hf_model.feature_extractor

			for name, value in fairseq_dict.items():
						UpperCamelCase__   =    False
						if "conv_layers" in name:
									load_conv_layer(
									    _A			,       _A			,       _A			,       _A			,       hf_model.config.feat_extract_norm == "group"			,       )
									UpperCamelCase__   =    True
						else:
									for key, mapped_key in MAPPING.items():
												UpperCamelCase__   =    mapped_key

												if key in name:
															UpperCamelCase__   =    True
															if "*" in mapped_key:
																		UpperCamelCase__   =    name.split(_A					)[0].split("."					)[-2]
																		UpperCamelCase__   =    mapped_key.replace("*"			,       _A					)
															if "weight_g" in name:
																		UpperCamelCase__   =    "weight_g"
															elif "weight_v" in name:
																		UpperCamelCase__   =    "weight_v"
															elif "weight" in name:
																		UpperCamelCase__   =    "weight"
															elif "bias" in name:
																		UpperCamelCase__   =    "bias"
															else:
																		UpperCamelCase__   =    None
															set_recursively(_A			,       _A			,       _A			,       _A			,       _A					)
												continue
						if not is_used:
									unused_weights.append(_A					)

			logger.warning(F'''Unused weights: {unused_weights}'''					)
def     UpperCamelCase_(			_A				:Any			,       _A				:List[Any]			,       _A				:Union[str, Any]			,       _A				:Dict			,       _A				:Union[str, Any]					)->						Optional[Any]:
			UpperCamelCase__   =    full_name.split("conv_layers."					)[-1]
			UpperCamelCase__   =    name.split("."					)
			UpperCamelCase__   =    int(items[0]					)
			UpperCamelCase__   =    int(items[1]					)

			if type_id == 0:
						if "bias" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
									    F'''{full_name} has size {value.shape}, but'''
									    F''' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'''
									)
									UpperCamelCase__   =    value
									logger.info(F'''Feat extract conv layer {layer_id} was initialized from {full_name}.'''					)
						elif "weight" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
									    F'''{full_name} has size {value.shape}, but'''
									    F''' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'''
									)
									UpperCamelCase__   =    value
									logger.info(F'''Feat extract conv layer {layer_id} was initialized from {full_name}.'''					)
			elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
						if "bias" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
									    F'''{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was'''
									    " found."
									)
									UpperCamelCase__   =    value
									logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''					)
						elif "weight" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
									    F'''{full_name} has size {value.shape}, but'''
									    F''' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.'''
									)
									UpperCamelCase__   =    value
									logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''					)
			else:
						unused_weights.append(_A					)
def     UpperCamelCase_(			_A				:Dict					)->						Union[str, Any]:
			UpperCamelCase__   =    HubertConfig()
			UpperCamelCase__   =    model.config

			UpperCamelCase__   =    fs_config.activation_dropout
			UpperCamelCase__   =    False
			UpperCamelCase__   =    fs_config.attention_dropout
			UpperCamelCase__   =    False
			UpperCamelCase__   =    eval(fs_config.extractor_conv_feature_layers					)
			UpperCamelCase__   =    [x[0] for x in conv_layers]
			UpperCamelCase__   =    [x[1] for x in conv_layers]
			UpperCamelCase__   =    [x[2] for x in conv_layers]
			UpperCamelCase__   =    "gelu"
			UpperCamelCase__   =    "layer" if fs_config.extractor_mode == "layer_norm" else "group"
			UpperCamelCase__   =    False
			UpperCamelCase__   =    0.0
			UpperCamelCase__   =    0.0
			UpperCamelCase__   =    fs_config.activation_fn
			UpperCamelCase__   =    fs_config.dropout
			UpperCamelCase__   =    fs_config.encoder_embed_dim
			UpperCamelCase__   =    0.0_2
			UpperCamelCase__   =    fs_config.encoder_ffn_embed_dim
			UpperCamelCase__   =    1e-5
			UpperCamelCase__   =    0.0
			UpperCamelCase__   =    fs_config.encoder_attention_heads
			UpperCamelCase__   =    fs_config.conv_pos_groups
			UpperCamelCase__   =    fs_config.conv_pos
			UpperCamelCase__   =    len(_A					)
			UpperCamelCase__   =    fs_config.encoder_layers

			return config
@torch.no_grad()
def     UpperCamelCase_(			_A				:str			,       _A				:Union[str, Any]=None					)->						str:
			UpperCamelCase__   =    distilhubert().model.model

			if config_path is not None:
						UpperCamelCase__   =    HubertConfig.from_pretrained(_A					)
			else:
						UpperCamelCase__   =    convert_config(_A					)
			UpperCamelCase__   =    model.eval()

			UpperCamelCase__   =    WavaVecaFeatureExtractor(
			    feature_size=1			,       sampling_rate=1_60_00			,       padding_value=0			,       do_normalize=_A			,       return_attention_mask=_A			,       )
			UpperCamelCase__   =    HubertModel(_A					)

			recursively_load_weights(_A			,       _A					)

			feature_extractor.save_pretrained(_A					)
			hf_model.save_pretrained(_A					)


if __name__ == "__main__":
						__UpperCamelCase      						=    argparse.ArgumentParser()
						parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
						parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
						__UpperCamelCase      						=    parser.parse_args()
						convert_hubert_checkpoint(args.pytorch_dump_folder_path, args.config_path)






import qiskit
from qiskit.providers import Backend
def     UpperCamelCase_(			_A				:int			,       _A				:int					)->						tuple[qiskit.QuantumCircuit, str, str]:
			UpperCamelCase__, UpperCamelCase__   =    bin(_A					)[2:], bin(_A					)[2:]  # Remove leading '0b'

			# Ensure that both strings are of the same length
			if len(_A					) > len(_A					):
						UpperCamelCase__   =    y.zfill(len(_A					)					)
			else:
						UpperCamelCase__   =    x.zfill(len(_A					)					)

			# We need (3 * number of bits in the larger number)+1 qBits
			# The second parameter is the number of classical registers, to measure the result
			UpperCamelCase__   =    qiskit.QuantumCircuit((len(_A					) * 3) + 1			,       len(_A					) + 1					)

			# We are essentially "not-ing" the bits that are 1
			# Reversed because it's easier to perform ops on more significant bits
			for i in range(len(_A					)					):
						if x[::-1][i] == "1":
									circuit.x(_A					)
			for j in range(len(_A					)					):
						if y[::-1][j] == "1":
									circuit.x(len(_A					) + j					)

			return circuit, x, y
def     UpperCamelCase_(			_A				:qiskit.QuantumCircuit			,       _A				:int			,       _A				:int			,       _A				:int			,       _A				:int			,       )->						Union[str, Any]:
			circuit.ccx(_A			,       _A			,       _A					)
			circuit.cx(_A			,       _A					)
			circuit.ccx(_A			,       _A			,       _A					)
			circuit.cx(_A			,       _A					)
			circuit.cx(_A			,       _A					)
def     UpperCamelCase_(			_A				:int			,       _A				:int			,       _A				:Backend = qiskit.Aer.get_backend("aer_simulator"					)			,       )->						int:

			if vala < 0 or vala < 0:
						raise ValueError("Both Integers must be positive!"					)

			# Store the Integers
			UpperCamelCase__, UpperCamelCase__, UpperCamelCase__   =    store_two_classics(_A			,       _A					)
			for i in range(len(_A					)					):
						full_adder(_A			,       _A			,       len(_A					) + i			,       len(_A					) + len(_A					) + i			,       len(_A					) + len(_A					) + i + 1					)
						circuit.barrier()  # Optional, just for aesthetics

			# Measure the resultant qBits
			for i in range(len(_A					) + 1					):
						circuit.measure([(len(_A					) * 2) + i]			,       [i]					)

			UpperCamelCase__   =    qiskit.execute(_A			,       _A			,       shots=1					).result()

			# The result is in binary. Convert it back to int
			return int(list(res.get_counts()					)[0]			,       2					)


if __name__ == "__main__":
						import doctest

						doctest.testmod()


