code: 
  
  
  
  import argparse
  
  import huggingface_hub
  import k_diffusion as K
  import torch
  
  from diffusers import UNetaDConditionModel
  
  
  __lowerCamelCase  				=					"""pcuenq/k-upscaler"""
  
  
  
  
  def     UpperCAmelCase__ (							__snake_case						,				__snake_case						,				*, __snake_case						,				__snake_case							):
    _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     UpperCAmelCase__ (							__snake_case						,				*, __snake_case						,				__snake_case							):
    _A           =    checkpoint[F'''{attention_prefix}.qkv_proj.weight'''].chunk(3						,				dim=0							)
    _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     UpperCAmelCase__ (							__snake_case						,				*, __snake_case						,				__snake_case						,				__snake_case							):
    _A           =    checkpoint[F'''{attention_prefix}.kv_proj.weight'''].chunk(2						,				dim=0							)
    _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     UpperCAmelCase__ (							__snake_case						,				__snake_case						,				__snake_case						,				__snake_case							):
    _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     UpperCAmelCase__ (							__snake_case						,				__snake_case							):
    _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     UpperCAmelCase__ (							__snake_case							):
    _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     UpperCAmelCase__ (							__snake_case							):
    _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__":
      __lowerCamelCase  				=					argparse.ArgumentParser()
  
      parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""")
      __lowerCamelCase  				=					parser.parse_args()
  
      main(args)
style_context: 
  
  
  
  def     UpperCAmelCase__ (							__snake_case						,				__snake_case = 1_000							)   -> str:
    if (not isinstance(__snake_case						,				__snake_case							)) or (digit_position <= 0):
      raise ValueError('''Digit position must be a positive integer'''							)
    elif (not isinstance(__snake_case						,				__snake_case							)) or (precision < 0):
      raise ValueError('''Precision must be a nonnegative integer'''							)
  
    # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
    # accurate
    _A           =    (
        4 * _subsum(__snake_case						,				1						,				__snake_case							)
        - 2 * _subsum(__snake_case						,				4						,				__snake_case							)
        - _subsum(__snake_case						,				5						,				__snake_case							)
        - _subsum(__snake_case						,				6						,				__snake_case							)
    )
  
    # return the first hex digit of the fractional part of the result
    return hex(int((sum_result % 1) * 16							)							)[2:]
  
  
  
  
  def     UpperCAmelCase__ (							__snake_case						,				__snake_case						,				__snake_case							)   -> float:
    _A           =    0.0
    for sum_index in range(digit_pos_to_extract + precision							):
      _A           =    8 * sum_index + denominator_addend
      if sum_index < digit_pos_to_extract:
        # if the exponential term is an integer and we mod it by the denominator
        # before dividing, only the integer part of the sum will change;
        # the fractional part will not
        _A           =    pow(
            16						,				digit_pos_to_extract - 1 - sum_index						,				__snake_case							)
      else:
        _A           =    pow(16						,				digit_pos_to_extract - 1 - sum_index							)
      total += exponential_term / denominator
    return total
  
  
  if __name__ == "__main__":
      import doctest
  
      doctest.testmod()