
import argparse

import huggingface_hub
import k_diffusion as K
import torch

from diffusers import UNetaDConditionModel


__magic_name__  :  List[Any]     			=   'pcuenq/k-upscaler'





def        lowerCAmelCase       (				snake_case__   :      Dict				,					snake_case__   :      Any				,					*, snake_case__   :      Tuple				,					snake_case__   :      Any )->			Optional[Any]:
    A_								=					{
        # norm1
        f'{diffusers_resnet_prefix}.norm1.linear.weight': checkpoint[f'{resnet_prefix}.main.0.mapper.weight'],
        f'{diffusers_resnet_prefix}.norm1.linear.bias': checkpoint[f'{resnet_prefix}.main.0.mapper.bias'],
        # conv1
        f'{diffusers_resnet_prefix}.conv1.weight': checkpoint[f'{resnet_prefix}.main.2.weight'],
        f'{diffusers_resnet_prefix}.conv1.bias': checkpoint[f'{resnet_prefix}.main.2.bias'],
        # norm2
        f'{diffusers_resnet_prefix}.norm2.linear.weight': checkpoint[f'{resnet_prefix}.main.4.mapper.weight'],
        f'{diffusers_resnet_prefix}.norm2.linear.bias': checkpoint[f'{resnet_prefix}.main.4.mapper.bias'],
        # conv2
        f'{diffusers_resnet_prefix}.conv2.weight': checkpoint[f'{resnet_prefix}.main.6.weight'],
        f'{diffusers_resnet_prefix}.conv2.bias': checkpoint[f'{resnet_prefix}.main.6.bias'],
    }

    if resnet.conv_shortcut is not None:
        rv.update(
            {
                f'{diffusers_resnet_prefix}.conv_shortcut.weight': checkpoint[f'{resnet_prefix}.skip.weight'],
            } )

    return rv





def        lowerCAmelCase       (				snake_case__   :      Tuple				,					*, snake_case__   :      str				,					snake_case__   :      int )->			List[str]:
    A_	,	A_	,	A_								=					checkpoint[f'{attention_prefix}.qkv_proj.weight'].chunk(3				,					dim=0 )
    A_	,	A_	,	A_								=					checkpoint[f'{attention_prefix}.qkv_proj.bias'].chunk(3				,					dim=0 )
    A_								=					{
        # norm
        f'{diffusers_attention_prefix}.norm1.linear.weight': checkpoint[f'{attention_prefix}.norm_in.mapper.weight'],
        f'{diffusers_attention_prefix}.norm1.linear.bias': checkpoint[f'{attention_prefix}.norm_in.mapper.bias'],
        # to_q
        f'{diffusers_attention_prefix}.attn1.to_q.weight': weight_q.squeeze(-1 ).squeeze(-1 ),
        f'{diffusers_attention_prefix}.attn1.to_q.bias': bias_q,
        # to_k
        f'{diffusers_attention_prefix}.attn1.to_k.weight': weight_k.squeeze(-1 ).squeeze(-1 ),
        f'{diffusers_attention_prefix}.attn1.to_k.bias': bias_k,
        # to_v
        f'{diffusers_attention_prefix}.attn1.to_v.weight': weight_v.squeeze(-1 ).squeeze(-1 ),
        f'{diffusers_attention_prefix}.attn1.to_v.bias': bias_v,
        # to_out
        f'{diffusers_attention_prefix}.attn1.to_out.0.weight': checkpoint[f'{attention_prefix}.out_proj.weight']
        .squeeze(-1 )
        .squeeze(-1 ),
        f'{diffusers_attention_prefix}.attn1.to_out.0.bias': checkpoint[f'{attention_prefix}.out_proj.bias'],
    }

    return rv





def        lowerCAmelCase       (				snake_case__   :      Dict				,					*, snake_case__   :      List[Any]				,					snake_case__   :      Any				,					snake_case__   :      Any )->			str:
    A_	,	A_								=					checkpoint[f'{attention_prefix}.kv_proj.weight'].chunk(2				,					dim=0 )
    A_	,	A_								=					checkpoint[f'{attention_prefix}.kv_proj.bias'].chunk(2				,					dim=0 )

    A_								=					{
        # norm2 (ada groupnorm)
        f'{diffusers_attention_prefix}.norm{diffusers_attention_index}.linear.weight': checkpoint[
            f'{attention_prefix}.norm_dec.mapper.weight'
        ],
        f'{diffusers_attention_prefix}.norm{diffusers_attention_index}.linear.bias': checkpoint[
            f'{attention_prefix}.norm_dec.mapper.bias'
        ],
        # layernorm on encoder_hidden_state
        f'{diffusers_attention_prefix}.attn{diffusers_attention_index}.norm_cross.weight': checkpoint[
            f'{attention_prefix}.norm_enc.weight'
        ],
        f'{diffusers_attention_prefix}.attn{diffusers_attention_index}.norm_cross.bias': checkpoint[
            f'{attention_prefix}.norm_enc.bias'
        ],
        # to_q
        f'{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_q.weight': checkpoint[
            f'{attention_prefix}.q_proj.weight'
        ]
        .squeeze(-1 )
        .squeeze(-1 ),
        f'{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_q.bias': checkpoint[
            f'{attention_prefix}.q_proj.bias'
        ],
        # to_k
        f'{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_k.weight': weight_k.squeeze(-1 ).squeeze(-1 ),
        f'{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_k.bias': bias_k,
        # to_v
        f'{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_v.weight': weight_v.squeeze(-1 ).squeeze(-1 ),
        f'{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_v.bias': bias_v,
        # to_out
        f'{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_out.0.weight': checkpoint[
            f'{attention_prefix}.out_proj.weight'
        ]
        .squeeze(-1 )
        .squeeze(-1 ),
        f'{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_out.0.bias': checkpoint[
            f'{attention_prefix}.out_proj.bias'
        ],
    }

    return rv





def        lowerCAmelCase       (				snake_case__   :      str				,					snake_case__   :      int				,					snake_case__   :      Dict				,					snake_case__   :      List[Any] )->			Optional[Any]:
    A_								=					"inner_model.u_net.u_blocks" if block_type == "up" else "inner_model.u_net.d_blocks"
    A_								=					f'{block_prefix}.{block_idx}'

    A_								=					{}

    if not hasattr(snake_case__				,					"attentions" ):
        A_								=					1  # resnet only
    elif not block.attentions[0].add_self_attention:
        A_								=					2  # resnet -> cross-attention
    else:
        A_								=					3  # resnet -> self-attention -> cross-attention)

    for resnet_idx, resnet in enumerate(block.resnets ):
        # diffusers_resnet_prefix = f"{diffusers_up_block_prefix}.resnets.{resnet_idx}"
        A_								=					f'{block_type}_blocks.{block_idx}.resnets.{resnet_idx}'
        A_								=					n * resnet_idx if block_type == "up" else n * resnet_idx + 1
        A_								=					f'{block_prefix}.{idx}' if block_type == "up" else f'{block_prefix}.{idx}'

        diffusers_checkpoint.update(
            resnet_to_diffusers_checkpoint(
                snake_case__				,					snake_case__				,					diffusers_resnet_prefix=snake_case__				,					resnet_prefix=snake_case__ ) )

    if hasattr(snake_case__				,					"attentions" ):
        for attention_idx, attention in enumerate(block.attentions ):
            A_								=					f'{block_type}_blocks.{block_idx}.attentions.{attention_idx}'
            A_								=					n * attention_idx + 1 if block_type == "up" else n * attention_idx + 2
            A_								=					f'{block_prefix}.{idx}'
            A_								=					f'{block_prefix}.{idx }'
            A_								=					1 if not attention.add_self_attention else 2
            A_								=					(
                n * attention_idx + cross_attention_index
                if block_type == "up"
                else n * attention_idx + cross_attention_index + 1
            )
            A_								=					f'{block_prefix}.{idx }'

            diffusers_checkpoint.update(
                cross_attn_to_diffusers_checkpoint(
                    snake_case__				,					diffusers_attention_prefix=snake_case__				,					diffusers_attention_index=2				,					attention_prefix=snake_case__				,					) )

            if attention.add_self_attention is True:
                diffusers_checkpoint.update(
                    self_attn_to_diffusers_checkpoint(
                        snake_case__				,					diffusers_attention_prefix=snake_case__				,					attention_prefix=snake_case__				,					) )

    return diffusers_checkpoint





def        lowerCAmelCase       (				snake_case__   :      Optional[int]				,					snake_case__   :      Dict )->			List[str]:
    A_								=					{}

    # pre-processing
    diffusers_checkpoint.update(
        {
            "conv_in.weight": checkpoint["inner_model.proj_in.weight"],
            "conv_in.bias": checkpoint["inner_model.proj_in.bias"],
        } )

    # timestep and class embedding
    diffusers_checkpoint.update(
        {
            "time_proj.weight": checkpoint["inner_model.timestep_embed.weight"].squeeze(-1 ),
            "time_embedding.linear_1.weight": checkpoint["inner_model.mapping.0.weight"],
            "time_embedding.linear_1.bias": checkpoint["inner_model.mapping.0.bias"],
            "time_embedding.linear_2.weight": checkpoint["inner_model.mapping.2.weight"],
            "time_embedding.linear_2.bias": checkpoint["inner_model.mapping.2.bias"],
            "time_embedding.cond_proj.weight": checkpoint["inner_model.mapping_cond.weight"],
        } )

    # down_blocks
    for down_block_idx, down_block in enumerate(model.down_blocks ):
        diffusers_checkpoint.update(block_to_diffusers_checkpoint(snake_case__				,					snake_case__				,					snake_case__				,					"down" ) )

    # up_blocks
    for up_block_idx, up_block in enumerate(model.up_blocks ):
        diffusers_checkpoint.update(block_to_diffusers_checkpoint(snake_case__				,					snake_case__				,					snake_case__				,					"up" ) )

    # post-processing
    diffusers_checkpoint.update(
        {
            "conv_out.weight": checkpoint["inner_model.proj_out.weight"],
            "conv_out.bias": checkpoint["inner_model.proj_out.bias"],
        } )

    return diffusers_checkpoint





def        lowerCAmelCase       (				snake_case__   :      str )->			List[str]:
    A_								=					original_config["input_channels"] + original_config["unet_cond_dim"]
    A_								=					original_config["input_channels"] + (1 if original_config["has_variance"] else 0)

    A_								=					original_config["channels"]

    assert (
        len(set(original_config["depths"] ) ) == 1
    ), "UNet2DConditionModel currently do not support blocks with different number of layers"
    A_								=					original_config["depths"][0]

    A_								=					original_config["mapping_cond_dim"]
    A_								=					original_config["cross_cond_dim"]

    A_								=					[]
    A_								=					[]
    for s, c in zip(original_config["self_attn_depths"]				,					original_config["cross_attn_depths"] ):
        if s:
            A_								=					"self"
            A_								=					"cross" if c else None
        elif c:
            A_								=					"cross"
            A_								=					None
        else:
            A_								=					None
            A_								=					None
        attna_types.append(snake_case__ )
        attna_types.append(snake_case__ )

    A_								=					UNetaDConditionModel(
        in_channels=snake_case__				,					out_channels=snake_case__				,					down_block_types=("KDownBlock2D", "KCrossAttnDownBlock2D", "KCrossAttnDownBlock2D", "KCrossAttnDownBlock2D")				,					mid_block_type=snake_case__				,					up_block_types=("KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KUpBlock2D")				,					block_out_channels=snake_case__				,					layers_per_block=snake_case__				,					act_fn="gelu"				,					norm_num_groups=snake_case__				,					cross_attention_dim=snake_case__				,					attention_head_dim=64				,					time_cond_proj_dim=snake_case__				,					resnet_time_scale_shift="scale_shift"				,					time_embedding_type="fourier"				,					timestep_post_act="gelu"				,					conv_in_kernel=1				,					conv_out_kernel=1				,					)

    return unet





def        lowerCAmelCase       (				snake_case__   :      Optional[Any] )->			Dict:
    A_								=					torch.device("cuda" if torch.cuda.is_available() else "cpu" )

    A_								=					huggingface_hub.hf_hub_download(snake_case__				,					"config_laion_text_cond_latent_upscaler_2.json" )
    A_								=					huggingface_hub.hf_hub_download(
        snake_case__				,					"laion_text_cond_latent_upscaler_2_1_00470000_slim.pth" )
    print(f'loading original model configuration from {orig_config_path}' )
    print(f'loading original model checkpoint from {orig_weights_path}' )

    print("converting to diffusers unet" )
    A_								=					K.config.load_config(open(snake_case__ ) )["model"]
    A_								=					unet_model_from_original_config(snake_case__ )

    A_								=					torch.load(snake_case__				,					map_location=snake_case__ )["model_ema"]
    A_								=					unet_to_diffusers_checkpoint(snake_case__				,					snake_case__ )

    model.load_state_dict(snake_case__				,					strict=snake_case__ )
    model.save_pretrained(args.dump_path )
    print(f'saving converted unet model in {args.dump_path}' )


if __name__ == "__main__":
     __magic_name__  :  List[str]     			=   argparse.ArgumentParser()

     parser.add_argument('--dump_path', default=None, type=str, required=True, help='Path to the output model.')
     __magic_name__  :  Dict     			=   parser.parse_args()

     main(args)








import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute





def        lowerCAmelCase       (				snake_case__   :      int = 1				,					snake_case__   :      int = 1 )->			qiskit.result.counts.Counts:
    if isinstance(snake_case__				,					snake_case__ ) or isinstance(snake_case__				,					snake_case__ ):
        raise TypeError("inputs must be integers." )
    if (bit_a < 0) or (bit_a < 0):
        raise ValueError("inputs must be positive." )
    if (math.floor(snake_case__ ) != bit_a) or (math.floor(snake_case__ ) != bit_a):
        raise ValueError("inputs must be exact integers." )
    if (bit_a > 1) or (bit_a > 1):
        raise ValueError("inputs must be less or equal to 1." )

    # build registers
    A_								=					QuantumRegister(2				,					"qr" )
    A_								=					ClassicalRegister(2				,					"cr" )

    A_								=					QuantumCircuit(snake_case__				,					snake_case__ )

    # entanglement the qubits
    quantum_circuit.h(1 )
    quantum_circuit.cx(1				,					0 )

    # send the information
    A_								=					str(snake_case__ ) + str(snake_case__ )

    if c_information == "11":
        quantum_circuit.x(1 )
        quantum_circuit.z(1 )
    elif c_information == "10":
        quantum_circuit.z(1 )
    elif c_information == "01":
        quantum_circuit.x(1 )
    else:
        quantum_circuit.i(1 )

    # unentangled the circuit
    quantum_circuit.cx(1				,					0 )
    quantum_circuit.h(1 )

    # measure the circuit
    quantum_circuit.measure(snake_case__				,					snake_case__ )

    A_								=					Aer.get_backend("aer_simulator" )
    A_								=					execute(snake_case__				,					snake_case__				,					shots=1000 )

    return job.result().get_counts(snake_case__ )


if __name__ == "__main__":
     print(f"""Counts for classical state send: {superdense_coding(1,1)}""")






