

import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision import transforms

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling
def   a   (    A__			:     Tuple  )					->   Optional[int]:





      """simple docstring"""



      _lowercase			 =[2, 2, 6, 2] if 'tiny' in model_name else [2, 2, 18, 2]
      _lowercase			 =True if 'large' in model_name or 'huge' in model_name else False
      _lowercase			 =True if 'large' in model_name or 'huge' in model_name else False
      _lowercase			 =True if 'large' in model_name or 'huge' in model_name else False

      if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
            if "fl3" in model_name:
                  _lowercase			 =[3, 3, 3, 3]
                  _lowercase			 =[5, 5, 5, 5]
            elif "fl4" in model_name:
                  _lowercase			 =[4, 4, 4, 4]
                  _lowercase			 =[3, 3, 3, 3]

      if "tiny" in model_name or "small" in model_name or "base" in model_name:
            _lowercase			 =[3, 3, 3, 3]
            if "lrf" in model_name:
                  _lowercase			 =[3, 3, 3, 3]
            else:
                  _lowercase			 =[2, 2, 2, 2]

      if "tiny" in model_name:
            _lowercase			 =96
      elif "small" in model_name:
            _lowercase			 =96
      elif "base" in model_name:
            _lowercase			 =128
      elif "large" in model_name:
            _lowercase			 =192
      elif "xlarge" in model_name:
            _lowercase			 =256
      elif "huge" in model_name:
            _lowercase			 =352

      # set label information
      _lowercase			 ='huggingface/label-files'
      if "large" in model_name or "huge" in model_name:
            _lowercase			 ='imagenet-22k-id2label.json'
      else:
            _lowercase			 ='imagenet-1k-id2label.json'

      _lowercase			 =json.load(open(hf_hub_download(_lowerCAmelCase   ,     _lowerCAmelCase   ,     repo_type='dataset'  )   ,     'r'  )  )
      _lowercase			 ={int(_lowerCAmelCase  ): v for k, v in idalabel.items()}
      _lowercase			 ={v: k for k, v in idalabel.items()}

      _lowercase			 =FocalNetConfig(
          embed_dim=_lowerCAmelCase   ,     depths=_lowerCAmelCase   ,     focal_levels=_lowerCAmelCase   ,     focal_windows=_lowerCAmelCase   ,     use_conv_embed=_lowerCAmelCase   ,     idalabel=_lowerCAmelCase   ,     labelaid=_lowerCAmelCase   ,     use_post_layernorm=_lowerCAmelCase   ,     use_layerscale=_lowerCAmelCase   ,     )

      return config
def   a   (    A__			:     Optional[Any]  )					->   Optional[int]:





      """simple docstring"""



      if "patch_embed.proj" in name:
            _lowercase			 =name.replace('patch_embed.proj'   ,     'embeddings.patch_embeddings.projection'  )
      if "patch_embed.norm" in name:
            _lowercase			 =name.replace('patch_embed.norm'   ,     'embeddings.norm'  )
      if "layers" in name:
            _lowercase			 ='encoder.' + name
      if "encoder.layers" in name:
            _lowercase			 =name.replace('encoder.layers'   ,     'encoder.stages'  )
      if "downsample.proj" in name:
            _lowercase			 =name.replace('downsample.proj'   ,     'downsample.projection'  )
      if "blocks" in name:
            _lowercase			 =name.replace('blocks'   ,     'layers'  )
      if "modulation.f.weight" in name or "modulation.f.bias" in name:
            _lowercase			 =name.replace('modulation.f'   ,     'modulation.projection_in'  )
      if "modulation.h.weight" in name or "modulation.h.bias" in name:
            _lowercase			 =name.replace('modulation.h'   ,     'modulation.projection_context'  )
      if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
            _lowercase			 =name.replace('modulation.proj'   ,     'modulation.projection_out'  )

      if name == "norm.weight":
            _lowercase			 ='layernorm.weight'
      if name == "norm.bias":
            _lowercase			 ='layernorm.bias'

      if "head" in name:
            _lowercase			 =name.replace('head'   ,     'classifier'  )
      else:
            _lowercase			 ='focalnet.' + name

      return name
def   a   (    A__			:     Any   ,     A__			:     str   ,     A__			:     Optional[int]=False  )					->   str:





      """simple docstring"""



      _lowercase			 ={
          'focalnet-tiny': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth',
          'focalnet-tiny-lrf': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth',
          'focalnet-small': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth',
          'focalnet-small-lrf': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth',
          'focalnet-base': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth',
          'focalnet-base-lrf': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth',
          'focalnet-large-lrf-fl3': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth',
          'focalnet-large-lrf-fl4': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth',
          'focalnet-xlarge-lrf-fl3': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth',
          'focalnet-xlarge-lrf-fl4': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth',
      }
      # fmt: on

      _lowercase			 =model_name_to_url[model_name]
      print('Checkpoint URL: '   ,     _lowerCAmelCase  )
      _lowercase			 =torch.hub.load_state_dict_from_url(_lowerCAmelCase   ,     map_location='cpu'  )['model']

      # rename keys
      for key in state_dict.copy().keys():
            _lowercase			 =state_dict.pop(_lowerCAmelCase  )
            _lowercase			 =val

      _lowercase			 =get_focalnet_config(_lowerCAmelCase  )
      _lowercase			 =FocalNetForImageClassification(_lowerCAmelCase  )
      model.eval()

      # load state dict
      model.load_state_dict(_lowerCAmelCase  )

      # verify conversion
      _lowercase			 ='http://images.cocodataset.org/val2017/000000039769.jpg'

      _lowercase			 =BitImageProcessor(
          do_resize=_lowerCAmelCase   ,     size={'shortest_edge': 256}   ,     resample=PILImageResampling.BILINEAR   ,     do_center_crop=_lowerCAmelCase   ,     crop_size=224   ,     do_normalize=_lowerCAmelCase   ,     image_mean=_lowerCAmelCase   ,     image_std=_lowerCAmelCase   ,     )
      _lowercase			 =Image.open(requests.get(_lowerCAmelCase   ,     stream=_lowerCAmelCase  ).raw  )
      _lowercase			 =processor(images=_lowerCAmelCase   ,     return_tensors='pt'  )

      _lowercase			 =transforms.Compose(
          [
              transforms.Resize(256  ),
              transforms.CenterCrop(224  ),
              transforms.ToTensor(),
              transforms.Normalize(mean=[0.485, 0.456, 0.406]   ,     std=[0.229, 0.224, 0.225]  ),
          ]  )

      _lowercase			 =image_transforms(_lowerCAmelCase  ).unsqueeze(0  )

      # verify pixel_values
      assert torch.allclose(inputs.pixel_values   ,     _lowerCAmelCase   ,     atol=1e-4  )

      _lowercase			 =model(**_lowerCAmelCase  )

      _lowercase			 =outputs.logits.argmax(-1  ).item()
      print('Predicted class:'   ,     model.config.idalabel[predicted_class_idx]  )

      print('First values of logits:'   ,     outputs.logits[0, :3]  )

      if model_name == "focalnet-tiny":
            _lowercase			 =torch.tensor([0.2166, -0.4368, 0.2191]  )
      elif model_name == "focalnet-tiny-lrf":
            _lowercase			 =torch.tensor([1.1669, 0.0125, -0.1695]  )
      elif model_name == "focalnet-small":
            _lowercase			 =torch.tensor([0.4917, -0.0430, 0.1341]  )
      elif model_name == "focalnet-small-lrf":
            _lowercase			 =torch.tensor([-0.2588, -0.5342, -0.2331]  )
      elif model_name == "focalnet-base":
            _lowercase			 =torch.tensor([-0.1655, -0.4090, -0.1730]  )
      elif model_name == "focalnet-base-lrf":
            _lowercase			 =torch.tensor([0.5306, -0.0483, -0.3928]  )
      assert torch.allclose(outputs.logits[0, :3]   ,     _lowerCAmelCase   ,     atol=1e-4  )
      print('Looks ok!'  )

      if pytorch_dump_folder_path is not None:
            print(F'''Saving model and processor of {model_name} to {pytorch_dump_folder_path}'''  )
            model.save_pretrained(_lowerCAmelCase  )
            processor.save_pretrained(_lowerCAmelCase  )

      if push_to_hub:
            print(F'''Pushing model and processor of {model_name} to the hub...'''  )
            model.push_to_hub(F'''{model_name}'''  )
            processor.push_to_hub(F'''{model_name}'''  )


if __name__ == "__main__":
  lowercase_             =     argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '--model_name',
      default='focalnet-tiny',
      type=str,
      help='Name of the FocalNet model you\'d like to convert.',
  )
  parser.add_argument(
      '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
  )
  parser.add_argument(
      '--push_to_hub',
      action='store_true',
      help='Whether to push the model and processor to the hub.',
  )

  lowercase_             =     parser.parse_args()
  convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





from __future__ import annotations

from typing import Any





class 				__lowerCAmelCase  :




  def __init__(       self							,     lowerCAmelCase      )						->				None:
        '''simple docstring'''






        _lowercase			 =num_of_nodes
        _lowercase			 =[]
        _lowercase			 ={}




  def 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase      )						->				None:
        '''simple docstring'''






        self.m_edges.append([u_node, v_node, weight]      )




  def 						A__  (       self							,     lowerCAmelCase      )						->				int:
        '''simple docstring'''






        if self.m_component[u_node] == u_node:
              return u_node
        return self.find_component(self.m_component[u_node]      )




  def 						A__  (       self							,     lowerCAmelCase      )						->				None:
        '''simple docstring'''






        if self.m_component[u_node] != u_node:
              for k in self.m_component:
                    _lowercase			 =self.find_component(lowerCAmelCase      )




  def 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase      )						->				None:
        '''simple docstring'''






        if component_size[u_node] <= component_size[v_node]:
              _lowercase			 =v_node
              component_size[v_node] += component_size[u_node]
              self.set_component(lowerCAmelCase      )

        elif component_size[u_node] >= component_size[v_node]:
              _lowercase			 =self.find_component(lowerCAmelCase      )
              component_size[u_node] += component_size[v_node]
              self.set_component(lowerCAmelCase      )




  def 						A__  (       self      )						->				None:
        '''simple docstring'''






        _lowercase			 =[]
        _lowercase			 =0

        _lowercase			 =[-1] * self.m_num_of_nodes

        # A list of components (initialized to all of the nodes)
        for node in range(self.m_num_of_nodes      ):
              self.m_component.update({node: node}      )
              component_size.append(1      )

        _lowercase			 =self.m_num_of_nodes

        while num_of_components > 1:
              for edge in self.m_edges:
                    _lowercase , _lowercase , _lowercase			 =edge

                    _lowercase			 =self.m_component[u]
                    _lowercase			 =self.m_component[v]

                    if u_component != v_component:

                          for component in (u_component, v_component):
                                if (
                                    minimum_weight_edge[component] == -1
                                    or minimum_weight_edge[component][2] > w
                                ):
                                      _lowercase			 =[u, v, w]

              for edge in minimum_weight_edge:
                    if isinstance(lowerCAmelCase							,     lowerCAmelCase      ):
                          _lowercase , _lowercase , _lowercase			 =edge

                          _lowercase			 =self.m_component[u]
                          _lowercase			 =self.m_component[v]

                          if u_component != v_component:
                                mst_weight += w
                                self.union(lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase      )
                                print(F'''Added edge [{u} - {v}]\nAdded weight: {w}\n'''      )
                                num_of_components -= 1

              _lowercase			 =[-1] * self.m_num_of_nodes
        print(F'''The total weight of the minimal spanning tree is: {mst_weight}'''      )
def   a   (    )					->   None:





      """simple docstring"""





if __name__ == "__main__":
  import doctest

  doctest.testmod()


