code: 
  
  
  import argparse
  import json
  import sys
  from dataclasses import dataclass, field
  from functools import partial
  from pathlib import Path
  from typing import List
  
  import torch
  import torch.nn as nn
  from huggingface_hub import cached_download, hf_hub_download
  from torch import Tensor
  
  from transformers import AutoImageProcessor, VanConfig, VanForImageClassification
  from transformers.models.deprecated.van.modeling_van import VanLayerScaling
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  lowerCAmelCase__ 	=				logging.get_logger(__name__)
  
  
  
  
  
  
  
  @dataclass
  class   lowerCAmelCase__ :
  
  
  
  
       '''simple docstring'''
       __SCREAMING_SNAKE_CASE						    =				42
       __SCREAMING_SNAKE_CASE						    =				field(default_factory=lowercase__)
       __SCREAMING_SNAKE_CASE						    =				field(default_factory=lowercase__)
  
  
       def 				_lowerCamelCase				(		self				,		__lowerCamelCase				,		__lowerCamelCase				,		__lowerCamelCase)    ->       Union[str, Any]:
              _A   : Optional[int]       					=				len(list(m.modules())) == 1 or isinstance(_A				,		nn.Convad) or isinstance(_A				,		nn.BatchNormad)
              if has_not_submodules:
                     if not isinstance(_A				,		_A):
                            self.traced.append(_A)
  
  
       def __call__(		self				,		__lowerCamelCase)    ->       Union[str, Any]:
              for m in self.module.modules():
                     self.handles.append(m.register_forward_hook(self._forward_hook))
              self.module(_A)
              [x.remove() for x in self.handles]
              return self
  
  
       @property
       def 				_lowerCamelCase				(		self)    ->       Union[str, Any]:
              # check the len of the state_dict keys to see if we have learnable params
              return list(filter(lambda __lowerCamelCase: len(list(x.state_dict().keys())) > 0				,		self.traced))
  
  
  
  
  
  
  
  @dataclass
  class   lowerCAmelCase__ :
  
  
  
  
       '''simple docstring'''
       __SCREAMING_SNAKE_CASE						    =				42
       __SCREAMING_SNAKE_CASE						    =				42
       __SCREAMING_SNAKE_CASE						    =				0
       __SCREAMING_SNAKE_CASE						    =				field(default_factory=lowercase__)
       __SCREAMING_SNAKE_CASE						    =				field(default_factory=lowercase__)
  
  
       def __call__(		self				,		__lowerCamelCase)    ->       List[Any]:
              _A   : Dict       					=				Tracker(self.dest)(_A).parametrized
              _A   : List[Any]       					=				Tracker(self.src)(_A).parametrized
  
              _A   : List[Any]       					=				list(filter(lambda __lowerCamelCase: type(_A) not in self.src_skip				,		_A))
              _A   : List[Any]       					=				list(filter(lambda __lowerCamelCase: type(_A) not in self.dest_skip				,		_A))
  
              if len(_A) != len(_A):
                     raise Exception(
                         F"Numbers of operations are different. Source module has {len(_A)} operations while"
                         F" destination module has {len(_A)}.")
  
              for dest_m, src_m in zip(_A				,		_A):
                     dest_m.load_state_dict(src_m.state_dict())
                     if self.verbose == 1:
                            print(F"Transfered from={src_m} to={dest_m}")
  
  
  
  
  def 							_UpperCAmelCase       (UpperCamelCase__  :						nn.Module       ,							UpperCamelCase__  :						nn.Module		):
         _A   : Any       					=				from_model.state_dict()
         _A   : List[str]       					=				our_model.state_dict()
         _A   : Optional[int]       					=				our_model.config
         _A   : List[str]       					=				[]
         for stage_idx in range(len(config.hidden_sizes		)		):
                for block_id in range(config.depths[stage_idx]		):
                       _A   : List[str]       					=				f"block{stage_idx + 1}.{block_id}.layer_scale_1"
                       _A   : Optional[int]       					=				f"van.encoder.stages.{stage_idx}.layers.{block_id}.attention_scaling.weight"
  
                       all_keys.append((from_key, to_key)		)
                       _A   : List[str]       					=				f"block{stage_idx + 1}.{block_id}.layer_scale_2"
                       _A   : Optional[Any]       					=				f"van.encoder.stages.{stage_idx}.layers.{block_id}.mlp_scaling.weight"
  
                       all_keys.append((from_key, to_key)		)
  
         for from_key, to_key in all_keys:
                _A   : Optional[Any]       					=				from_state_dict.pop(UpperCamelCase__		)
  
         our_model.load_state_dict(UpperCamelCase__		)
         return our_model
  def 							_UpperCAmelCase       (UpperCamelCase__  :						str       ,							UpperCamelCase__  :						VanConfig       ,							UpperCamelCase__  :						str       ,							UpperCamelCase__  :						nn.Module       ,							UpperCamelCase__  :						Path       ,							UpperCamelCase__  :						bool = True       ,							):
         print(f"Downloading weights for {name}..."		)
         _A   : str       					=				cached_download(UpperCamelCase__		)
         print(f"Converting {name}..."		)
         _A   : List[Any]       					=				torch.load(UpperCamelCase__		)['state_dict']
         from_model.load_state_dict(UpperCamelCase__		)
         from_model.eval()
         with torch.no_grad():
                _A   : int       					=				VanForImageClassification(UpperCamelCase__		).eval()
                _A   : int       					=				ModuleTransfer(src=UpperCamelCase__       ,							dest=UpperCamelCase__		)
                _A   : List[str]       					=				torch.randn((1, 3, 224, 224)		)
                module_transfer(UpperCamelCase__		)
                _A   : Tuple       					=				copy_parameters(UpperCamelCase__       ,							UpperCamelCase__		)
  
         if not torch.allclose(from_model(UpperCamelCase__		)       ,							our_model(UpperCamelCase__		).logits		):
                raise ValueError("The model logits don\'t match the original one."		)
  
         _A   : Any       					=				name
         print(UpperCamelCase__		)
  
         if push_to_hub:
                our_model.push_to_hub(
                    repo_path_or_name=save_directory / checkpoint_name       ,							commit_message="Add model"       ,							use_temp_dir=UpperCamelCase__       ,							)
  
                # we can use the convnext one
                _A   : Optional[int]       					=				AutoImageProcessor.from_pretrained("facebook/convnext-base-224-22k-1k"		)
                image_processor.push_to_hub(
                    repo_path_or_name=save_directory / checkpoint_name       ,							commit_message="Add image processor"       ,							use_temp_dir=UpperCamelCase__       ,							)
  
                print(f"Pushed {checkpoint_name}"		)
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Path       ,							UpperCamelCase__  :						str = None       ,							UpperCamelCase__  :						bool = True		):
         _A   : List[str]       					=				'imagenet-1k-id2label.json'
         _A   : List[Any]       					=				1000
  
         _A   : Any       					=				'huggingface/label-files'
         _A   : List[Any]       					=				num_labels
         _A   : int       					=				json.load(open(hf_hub_download(UpperCamelCase__       ,							UpperCamelCase__       ,							repo_type="dataset"		)       ,							"r"		)		)
         _A   : List[str]       					=				{int(UpperCamelCase__		): v for k, v in idalabel.items()}
  
         _A   : str       					=				idalabel
         _A   : Union[str, Any]       					=				{v: k for k, v in idalabel.items()}
  
         _A   : int       					=				partial(UpperCamelCase__       ,							num_labels=UpperCamelCase__       ,							idalabel=UpperCamelCase__       ,							labelaid=UpperCamelCase__		)
  
         _A   : int       					=				{
             'van-tiny': ImageNetPreTrainedConfig(
                 hidden_sizes=[32, 64, 160, 256]       ,							depths=[3, 3, 5, 2]       ,							mlp_ratios=[8, 8, 4, 4]       ,							),
             'van-small': ImageNetPreTrainedConfig(
                 hidden_sizes=[64, 128, 320, 512]       ,							depths=[2, 2, 4, 2]       ,							mlp_ratios=[8, 8, 4, 4]       ,							),
             'van-base': ImageNetPreTrainedConfig(
                 hidden_sizes=[64, 128, 320, 512]       ,							depths=[3, 3, 12, 3]       ,							mlp_ratios=[8, 8, 4, 4]       ,							),
             'van-large': ImageNetPreTrainedConfig(
                 hidden_sizes=[64, 128, 320, 512]       ,							depths=[3, 5, 27, 3]       ,							mlp_ratios=[8, 8, 4, 4]       ,							),
         }
  
         _A   : Optional[int]       					=				{
             'van-tiny': van_tiny,
             'van-small': van_small,
             'van-base': van_base,
             'van-large': van_large,
         }
  
         _A   : Tuple       					=				{
             'van-tiny': (
                 'https://huggingface.co/Visual-Attention-Network/VAN-Tiny-original/resolve/main/van_tiny_754.pth.tar'
             ),
             'van-small': (
                 'https://huggingface.co/Visual-Attention-Network/VAN-Small-original/resolve/main/van_small_811.pth.tar'
             ),
             'van-base': (
                 'https://huggingface.co/Visual-Attention-Network/VAN-Base-original/resolve/main/van_base_828.pth.tar'
             ),
             'van-large': (
                 'https://huggingface.co/Visual-Attention-Network/VAN-Large-original/resolve/main/van_large_839.pth.tar'
             ),
         }
  
         if model_name:
                convert_weight_and_push(
                    UpperCamelCase__       ,							names_to_config[model_name]       ,							checkpoint=names_to_original_checkpoints[model_name]       ,							from_model=names_to_original_models[model_name]()       ,							save_directory=UpperCamelCase__       ,							push_to_hub=UpperCamelCase__       ,							)
         else:
                for model_name, config in names_to_config.items():
                       convert_weight_and_push(
                           UpperCamelCase__       ,							UpperCamelCase__       ,							checkpoint=names_to_original_checkpoints[model_name]       ,							from_model=names_to_original_models[model_name]()       ,							save_directory=UpperCamelCase__       ,							push_to_hub=UpperCamelCase__       ,							)
  
  
  if __name__ == "__main__":
      lowerCAmelCase__ 	=				argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          '--model-name',
          default=None,
          type=str,
          help=(
              'The name of the model you wish to convert, it must be one of the supported resnet* architecture,'
              ' currently: van-tiny/small/base/large. If `None`, all of them will the converted.'
          ),
      )
      parser.add_argument(
          '--pytorch_dump_folder_path',
          default=None,
          type=Path,
          required=True,
          help='Path to the output PyTorch model directory.',
      )
      parser.add_argument(
          '--van_dir',
          required=True,
          type=Path,
          help=(
              'A path to VAN\'s original implementation directory. You can download from here:'
              ' https://github.com/Visual-Attention-Network/VAN-Classification'
          ),
      )
      parser.add_argument(
          '--push_to_hub',
          default=True,
          type=bool,
          required=False,
          help='If True, push model and image processor to the hub.',
      )
  
      lowerCAmelCase__ 	=				parser.parse_args()
      lowerCAmelCase__ 	=				args.pytorch_dump_folder_path
      pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
      lowerCAmelCase__ 	=				args.van_dir
      # append the path to the parents to maskformer dir
      sys.path.append(str(van_dir.parent))
      from van.models.van import van_base, van_large, van_small, van_tiny
  
      convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
  
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_tf_available,
      is_torch_available,
      is_vision_available,
  )
  
  
  lowerCAmelCase__   	=				{
      'configuration_segformer': ['SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'SegformerConfig', 'SegformerOnnxConfig']
  }
  
  try:
      if not is_vision_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      lowerCAmelCase__   	=				['SegformerFeatureExtractor']
      lowerCAmelCase__   	=				['SegformerImageProcessor']
  
  try:
      if not is_torch_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      lowerCAmelCase__   	=				[
          'SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
          'SegformerDecodeHead',
          'SegformerForImageClassification',
          'SegformerForSemanticSegmentation',
          'SegformerLayer',
          'SegformerModel',
          'SegformerPreTrainedModel',
      ]
  
  try:
      if not is_tf_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      lowerCAmelCase__   	=				[
          'TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
          'TFSegformerDecodeHead',
          'TFSegformerForImageClassification',
          'TFSegformerForSemanticSegmentation',
          'TFSegformerModel',
          'TFSegformerPreTrainedModel',
      ]
  
  
  if TYPE_CHECKING:
      from .configuration_segformer import SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, SegformerConfig, SegformerOnnxConfig
  
      try:
          if not is_vision_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .feature_extraction_segformer import SegformerFeatureExtractor
          from .image_processing_segformer import SegformerImageProcessor
  
      try:
          if not is_torch_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .modeling_segformer import (
              SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
              SegformerDecodeHead,
              SegformerForImageClassification,
              SegformerForSemanticSegmentation,
              SegformerLayer,
              SegformerModel,
              SegformerPreTrainedModel,
          )
      try:
          if not is_tf_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .modeling_tf_segformer import (
              TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFSegformerDecodeHead,
              TFSegformerForImageClassification,
              TFSegformerForSemanticSegmentation,
              TFSegformerModel,
              TFSegformerPreTrainedModel,
          )
  
  else:
      import sys
  
      lowerCAmelCase__   	=				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
  