

import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
__A :  str			  =      logging.get_logger(__name__)
def 		SCREAMING_SNAKE_CASE__					(				_UpperCAmelCase					)       ->			str:



    '''simple docstring'''






    lowerCAmelCase					:      Optional[int]           =   SwinConfig(
        embed_dim=192,   depths=(2, 2, 18, 2),   num_heads=(6, 12, 24, 48),   window_size=12,   out_features=['stage2', 'stage3', 'stage4'],   )

    lowerCAmelCase					:      int           =   DetaConfig(
        backbone_config=lowercase_,   num_queries=900,   encoder_ffn_dim=2_048,   decoder_ffn_dim=2_048,   num_feature_levels=5,   assign_first_stage=lowercase_,   with_box_refine=lowercase_,   two_stage=lowercase_,   )

    # set labels
    lowerCAmelCase					:      Optional[int]           =   "huggingface/label-files"
    if "o365" in model_name:
        lowerCAmelCase					:      Dict           =   366
        lowerCAmelCase					:      List[str]           =   "object365-id2label.json"
    else:
        lowerCAmelCase					:      Dict           =   91
        lowerCAmelCase					:      str           =   "coco-detection-id2label.json"

    lowerCAmelCase					:      Any           =   num_labels
    lowerCAmelCase					:      Optional[int]           =   json.load(open(cached_download(hf_hub_url(lowercase_,   lowercase_,   repo_type='dataset'					)					),   'r'					)					)
    lowerCAmelCase					:      Tuple           =   {int(lowercase_					): v for k, v in idalabel.items()}
    lowerCAmelCase					:      Optional[Any]           =   idalabel
    lowerCAmelCase					:      str           =   {v: k for k, v in idalabel.items()}

    return config
def 		SCREAMING_SNAKE_CASE__					(				_UpperCAmelCase					)       ->			Tuple:



    '''simple docstring'''






    lowerCAmelCase					:      Any           =   []

    # stem
    # fmt: off
    rename_keys.append(('backbone.0.body.patch_embed.proj.weight', 'model.backbone.model.embeddings.patch_embeddings.projection.weight')					)
    rename_keys.append(('backbone.0.body.patch_embed.proj.bias', 'model.backbone.model.embeddings.patch_embeddings.projection.bias')					)
    rename_keys.append(('backbone.0.body.patch_embed.norm.weight', 'model.backbone.model.embeddings.norm.weight')					)
    rename_keys.append(('backbone.0.body.patch_embed.norm.bias', 'model.backbone.model.embeddings.norm.bias')					)
    # stages
    for i in range(len(config.backbone_config.depths					)					):
        for j in range(config.backbone_config.depths[i]					):
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.norm1.weight", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.norm1.bias", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.norm2.weight", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.norm2.bias", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias", f"model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias")					)

        if i < 3:
            rename_keys.append((f"backbone.0.body.layers.{i}.downsample.reduction.weight", f"model.backbone.model.encoder.layers.{i}.downsample.reduction.weight")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.downsample.norm.weight", f"model.backbone.model.encoder.layers.{i}.downsample.norm.weight")					)
            rename_keys.append((f"backbone.0.body.layers.{i}.downsample.norm.bias", f"model.backbone.model.encoder.layers.{i}.downsample.norm.bias")					)

    rename_keys.append(('backbone.0.body.norm1.weight', 'model.backbone.model.hidden_states_norms.stage2.weight')					)
    rename_keys.append(('backbone.0.body.norm1.bias', 'model.backbone.model.hidden_states_norms.stage2.bias')					)
    rename_keys.append(('backbone.0.body.norm2.weight', 'model.backbone.model.hidden_states_norms.stage3.weight')					)
    rename_keys.append(('backbone.0.body.norm2.bias', 'model.backbone.model.hidden_states_norms.stage3.bias')					)
    rename_keys.append(('backbone.0.body.norm3.weight', 'model.backbone.model.hidden_states_norms.stage4.weight')					)
    rename_keys.append(('backbone.0.body.norm3.bias', 'model.backbone.model.hidden_states_norms.stage4.bias')					)

    # transformer encoder
    for i in range(config.encoder_layers					):
        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight", f"model.encoder.layers.{i}.self_attn.sampling_offsets.weight")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias", f"model.encoder.layers.{i}.self_attn.sampling_offsets.bias")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.attention_weights.weight", f"model.encoder.layers.{i}.self_attn.attention_weights.weight")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.attention_weights.bias", f"model.encoder.layers.{i}.self_attn.attention_weights.bias")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.value_proj.weight", f"model.encoder.layers.{i}.self_attn.value_proj.weight")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.value_proj.bias", f"model.encoder.layers.{i}.self_attn.value_proj.bias")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.output_proj.weight", f"model.encoder.layers.{i}.self_attn.output_proj.weight")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.self_attn.output_proj.bias", f"model.encoder.layers.{i}.self_attn.output_proj.bias")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.norm1.weight", f"model.encoder.layers.{i}.self_attn_layer_norm.weight")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.norm1.bias", f"model.encoder.layers.{i}.self_attn_layer_norm.bias")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.linear1.weight", f"model.encoder.layers.{i}.fc1.weight")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.linear1.bias", f"model.encoder.layers.{i}.fc1.bias")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.linear2.weight", f"model.encoder.layers.{i}.fc2.weight")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.linear2.bias", f"model.encoder.layers.{i}.fc2.bias")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.norm2.weight", f"model.encoder.layers.{i}.final_layer_norm.weight")					)
        rename_keys.append((f"transformer.encoder.layers.{i}.norm2.bias", f"model.encoder.layers.{i}.final_layer_norm.bias")					)

    # transformer decoder
    for i in range(config.decoder_layers					):
        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight", f"model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias", f"model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.attention_weights.weight", f"model.decoder.layers.{i}.encoder_attn.attention_weights.weight")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.attention_weights.bias", f"model.decoder.layers.{i}.encoder_attn.attention_weights.bias")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.value_proj.weight", f"model.decoder.layers.{i}.encoder_attn.value_proj.weight")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.value_proj.bias", f"model.decoder.layers.{i}.encoder_attn.value_proj.bias")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.output_proj.weight", f"model.decoder.layers.{i}.encoder_attn.output_proj.weight")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.cross_attn.output_proj.bias", f"model.decoder.layers.{i}.encoder_attn.output_proj.bias")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.norm1.weight", f"model.decoder.layers.{i}.encoder_attn_layer_norm.weight")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.norm1.bias", f"model.decoder.layers.{i}.encoder_attn_layer_norm.bias")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.self_attn.out_proj.weight", f"model.decoder.layers.{i}.self_attn.out_proj.weight")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.self_attn.out_proj.bias", f"model.decoder.layers.{i}.self_attn.out_proj.bias")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.norm2.weight", f"model.decoder.layers.{i}.self_attn_layer_norm.weight")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.norm2.bias", f"model.decoder.layers.{i}.self_attn_layer_norm.bias")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.linear1.weight", f"model.decoder.layers.{i}.fc1.weight")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.linear1.bias", f"model.decoder.layers.{i}.fc1.bias")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.linear2.weight", f"model.decoder.layers.{i}.fc2.weight")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.linear2.bias", f"model.decoder.layers.{i}.fc2.bias")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.norm3.weight", f"model.decoder.layers.{i}.final_layer_norm.weight")					)
        rename_keys.append((f"transformer.decoder.layers.{i}.norm3.bias", f"model.decoder.layers.{i}.final_layer_norm.bias")					)

    # fmt: on

    return rename_keys
def 		SCREAMING_SNAKE_CASE__					(				_UpperCAmelCase,   _UpperCAmelCase,   _UpperCAmelCase					)       ->			List[str]:



    '''simple docstring'''






    lowerCAmelCase					:      Tuple           =   dct.pop(lowercase_					)
    lowerCAmelCase					:      str           =   val
def 		SCREAMING_SNAKE_CASE__					(				_UpperCAmelCase,   _UpperCAmelCase					)       ->			Optional[int]:



    '''simple docstring'''






    lowerCAmelCase					:      Optional[Any]           =   [int(backbone_config.embed_dim * 2**i					) for i in range(len(backbone_config.depths					)					)]
    for i in range(len(backbone_config.depths					)					):
        lowerCAmelCase					:      List[str]           =   num_features[i]
        for j in range(backbone_config.depths[i]					):
            # fmt: off
            # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
            lowerCAmelCase					:      Tuple           =   state_dict.pop(f"backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight"					)
            lowerCAmelCase					:      List[str]           =   state_dict.pop(f"backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias"					)
            # next, add query, keys and values (in that order) to the state dict
            lowerCAmelCase					:      Any           =   in_proj_weight[:dim, :]
            lowerCAmelCase					:      List[str]           =   in_proj_bias[: dim]
            lowerCAmelCase					:      Dict           =   in_proj_weight[
                dim : dim * 2, :
            ]
            lowerCAmelCase					:      List[Any]           =   in_proj_bias[
                dim : dim * 2
            ]
            lowerCAmelCase					:      Tuple           =   in_proj_weight[
                -dim :, :
            ]
            lowerCAmelCase					:      List[Any]           =   in_proj_bias[-dim :]
            # fmt: on
def 		SCREAMING_SNAKE_CASE__					(				_UpperCAmelCase,   _UpperCAmelCase					)       ->			str:



    '''simple docstring'''






    lowerCAmelCase					:      Any           =   config.d_model
    for i in range(config.decoder_layers					):
        # read in weights + bias of input projection layer of self-attention
        lowerCAmelCase					:      List[str]           =   state_dict.pop(f"transformer.decoder.layers.{i}.self_attn.in_proj_weight"					)
        lowerCAmelCase					:      Any           =   state_dict.pop(f"transformer.decoder.layers.{i}.self_attn.in_proj_bias"					)
        # next, add query, keys and values (in that order) to the state dict
        lowerCAmelCase					:      Union[str, Any]           =   in_proj_weight[:hidden_size, :]
        lowerCAmelCase					:      Optional[int]           =   in_proj_bias[:hidden_size]
        lowerCAmelCase					:      Union[str, Any]           =   in_proj_weight[
            hidden_size : hidden_size * 2, :
        ]
        lowerCAmelCase					:      List[Any]           =   in_proj_bias[hidden_size : hidden_size * 2]
        lowerCAmelCase					:      Optional[Any]           =   in_proj_weight[-hidden_size:, :]
        lowerCAmelCase					:      int           =   in_proj_bias[-hidden_size:]
def 		SCREAMING_SNAKE_CASE__					(				)       ->			Union[str, Any]:



    '''simple docstring'''






    lowerCAmelCase					:      List[str]           =   "http://images.cocodataset.org/val2017/000000039769.jpg"
    lowerCAmelCase					:      Optional[Any]           =   Image.open(requests.get(lowercase_,   stream=lowercase_					).raw					)

    return im
@torch.no_grad()
def 		SCREAMING_SNAKE_CASE__					(				_UpperCAmelCase,   _UpperCAmelCase,   _UpperCAmelCase					)       ->			List[str]:



    '''simple docstring'''






    lowerCAmelCase					:      Tuple           =   get_deta_config(lowercase_					)

    # load original state dict
    if model_name == "deta-swin-large":
        lowerCAmelCase					:      Optional[int]           =   hf_hub_download(repo_id='nielsr/deta-checkpoints',   filename='adet_swin_ft.pth'					)
    elif model_name == "deta-swin-large-o365":
        lowerCAmelCase					:      Tuple           =   hf_hub_download(repo_id='jozhang97/deta-swin-l-o365',   filename='deta_swin_pt_o365.pth'					)
    else:
        raise ValueError(f"Model name {model_name} not supported"					)

    lowerCAmelCase					:      List[str]           =   torch.load(lowercase_,   map_location='cpu'					)["model"]

    # original state dict
    for name, param in state_dict.items():
        print(lowercase_,   param.shape					)

    # rename keys
    lowerCAmelCase					:      Dict           =   create_rename_keys(lowercase_					)
    for src, dest in rename_keys:
        rename_key(lowercase_,   lowercase_,   lowercase_					)
    read_in_swin_q_k_v(lowercase_,   config.backbone_config					)
    read_in_decoder_q_k_v(lowercase_,   lowercase_					)

    # fix some prefixes
    for key in state_dict.copy().keys():
        if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
            lowerCAmelCase					:      Dict           =   state_dict.pop(lowercase_					)
            lowerCAmelCase					:      int           =   val
        if "input_proj" in key:
            lowerCAmelCase					:      Tuple           =   state_dict.pop(lowercase_					)
            lowerCAmelCase					:      int           =   val
        if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
            lowerCAmelCase					:      Optional[Any]           =   state_dict.pop(lowercase_					)
            lowerCAmelCase					:      Any           =   val

    # finally, create HuggingFace model and load state dict
    lowerCAmelCase					:      Any           =   DetaForObjectDetection(lowercase_					)
    model.load_state_dict(lowercase_					)
    model.eval()

    lowerCAmelCase					:      Tuple           =   "cuda" if torch.cuda.is_available() else "cpu"
    model.to(lowercase_					)

    # load image processor
    lowerCAmelCase					:      Dict           =   DetaImageProcessor(format='coco_detection'					)

    # verify our conversion on image
    lowerCAmelCase					:      str           =   prepare_img()
    lowerCAmelCase					:      Optional[int]           =   processor(images=lowercase_,   return_tensors='pt'					)
    lowerCAmelCase					:      Optional[int]           =   encoding["pixel_values"]
    lowerCAmelCase					:      List[Any]           =   model(pixel_values.to(lowercase_					)					)

    # verify logits
    print('Logits:',   outputs.logits[0, :3, :3]					)
    print('Boxes:',   outputs.pred_boxes[0, :3, :3]					)
    if model_name == "deta-swin-large":
        lowerCAmelCase					:      str           =   torch.tensor(
            [[-7.6_3_0_8, -2.8_4_8_5, -5.3_7_3_7], [-7.2_0_3_7, -4.5_5_0_5, -4.8_0_2_7], [-7.2_9_4_3, -4.2_6_1_1, -4.6_6_1_7]]					)
        lowerCAmelCase					:      str           =   torch.tensor([[0.4_9_8_7, 0.4_9_6_9, 0.9_9_9_9], [0.2_5_4_9, 0.5_4_9_8, 0.4_8_0_5], [0.5_4_9_8, 0.2_7_5_7, 0.0_5_6_9]]					)
    elif model_name == "deta-swin-large-o365":
        lowerCAmelCase					:      List[Any]           =   torch.tensor(
            [[-8.0_1_2_2, -3.5_7_2_0, -4.9_7_1_7], [-8.1_5_4_7, -3.6_8_8_6, -4.6_3_8_9], [-7.6_6_1_0, -3.6_1_9_4, -5.0_1_3_4]]					)
        lowerCAmelCase					:      int           =   torch.tensor([[0.2_5_2_3, 0.5_5_4_9, 0.4_8_8_1], [0.7_7_1_5, 0.4_1_4_9, 0.4_6_0_1], [0.5_5_0_3, 0.2_7_5_3, 0.0_5_7_5]]					)
    assert torch.allclose(outputs.logits[0, :3, :3],   expected_logits.to(lowercase_					),   atol=1e-4					)
    assert torch.allclose(outputs.pred_boxes[0, :3, :3],   expected_boxes.to(lowercase_					),   atol=1e-4					)
    print('Everything ok!'					)

    if pytorch_dump_folder_path:
        # Save model and processor
        logger.info(f"Saving PyTorch model and processor to {pytorch_dump_folder_path}..."					)
        Path(lowercase_					).mkdir(exist_ok=lowercase_					)
        model.save_pretrained(lowercase_					)
        processor.save_pretrained(lowercase_					)

    # Push to hub
    if push_to_hub:
        print('Pushing model and processor to hub...'					)
        model.push_to_hub(f"jozhang97/{model_name}"					)
        processor.push_to_hub(f"jozhang97/{model_name}"					)


if __name__ == "__main__":
 __A :  Union[str, Any]			  =      argparse.ArgumentParser()

 parser.add_argument(
     '''--model_name''',
     type=str,
     default='''deta-swin-large''',
     choices=['''deta-swin-large''', '''deta-swin-large-o365'''],
     help='''Name of the model you\'d like to convert.''',
 )
 parser.add_argument(
     '''--pytorch_dump_folder_path''',
     default=None,
     type=str,
     help='''Path to the folder to output PyTorch model.''',
 )
 parser.add_argument(
     '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
 )
 __A :  Optional[int]			  =      parser.parse_args()
 convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)












"""simple docstring"""


import numpy as np




def        lowercase__     (       lowercase_		,lowercase_		,lowercase_ = 1e-12		,lowercase_ = 100		,)       ->		tuple[float, np.ndarray]:




      """simple docstring"""

      assert np.shape(lowercase_      )[0] == np.shape(lowercase_      )[1]
      # Ensure proper dimensionality.
      assert np.shape(lowercase_      )[0] == np.shape(lowercase_      )[0]
      # Ensure inputs are either both complex or both real
      assert np.iscomplexobj(lowercase_      ) == np.iscomplexobj(lowercase_      )
      _UpperCamelCase   :						Dict    =							np.iscomplexobj(lowercase_      )
      if is_complex:
            # Ensure complex input_matrix is Hermitian
            assert np.array_equal(lowercase_		,input_matrix.conj().T      )

      # Set convergence to False. Will define convergence when we exceed max_iterations
      # or when we have small changes from one iteration to next.

      _UpperCamelCase   :						List[Any]    =							False
      _UpperCamelCase   :						Optional[int]    =							0
      _UpperCamelCase   :						int    =							0
      _UpperCamelCase   :						Optional[int]    =							1e12

      while not convergence:
            # Multiple matrix by the vector.
            _UpperCamelCase   :						Optional[int]    =							np.dot(lowercase_		,lowercase_      )
            # Normalize the resulting output vector.
            _UpperCamelCase   :						List[Any]    =							w / np.linalg.norm(lowercase_      )
            # Find rayleigh quotient
            # (faster than usual b/c we know vector is normalized already)
            _UpperCamelCase   :						Optional[Any]    =							vector.conj().T if is_complex else vector.T
            _UpperCamelCase   :						Dict    =							np.dot(lowercase_		,np.dot(lowercase_		,lowercase_      )      )

            # Check convergence.
            _UpperCamelCase   :						Optional[int]    =							np.abs(lambda_ - lambda_previous      ) / lambda_
            iterations += 1

            if error <= error_tol or iterations >= max_iterations:
                  _UpperCamelCase   :						List[Any]    =							True

            _UpperCamelCase   :						Tuple    =							lambda_

      if is_complex:
            _UpperCamelCase   :						Tuple    =							np.real(lambda_      )

      return lambda_, vector




def        lowercase__     (       )       ->		None:




      """simple docstring"""

      _UpperCamelCase   :						Dict    =							np.array([[41, 4, 20], [4, 26, 30], [20, 30, 50]]      )
      _UpperCamelCase   :						Optional[int]    =							np.array([41, 4, 20]      )
      _UpperCamelCase   :						Union[str, Any]    =							real_input_matrix.astype(np.complexaaa      )
      _UpperCamelCase   :						int    =							np.triu(1J * complex_input_matrix		,1      )
      complex_input_matrix += imag_matrix
      complex_input_matrix += -1 * imag_matrix.T
      _UpperCamelCase   :						Union[str, Any]    =							np.array([41, 4, 20]      ).astype(np.complexaaa      )

      for problem_type in ["real", "complex"]:
            if problem_type == "real":
                  _UpperCamelCase   :						Dict    =							real_input_matrix
                  _UpperCamelCase   :						Any    =							real_vector
            elif problem_type == "complex":
                  _UpperCamelCase   :						int    =							complex_input_matrix
                  _UpperCamelCase   :						Union[str, Any]    =							complex_vector

            # Our implementation.
            _UpperCamelCase,	_UpperCamelCase   :						int    =							power_iteration(lowercase_		,lowercase_      )

            # Numpy implementation.

            # Get eigenvalues and eigenvectors using built-in numpy
            # eigh (eigh used for symmetric or hermetian matrices).
            _UpperCamelCase,	_UpperCamelCase   :						str    =							np.linalg.eigh(lowercase_      )
            # Last eigenvalue is the maximum one.
            _UpperCamelCase   :						Any    =							eigen_values[-1]
            # Last column in this matrix is eigenvector corresponding to largest eigenvalue.
            _UpperCamelCase   :						Tuple    =							eigen_vectors[:, -1]

            # Check our implementation and numpy gives close answers.
            assert np.abs(eigen_value - eigen_value_max      ) <= 1e-6
            # Take absolute values element wise of each eigenvector.
            # as they are only unique to a minus sign.
            assert np.linalg.norm(np.abs(lowercase_      ) - np.abs(lowercase_      )      ) <= 1e-6


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  test_power_iteration()
