code: 
  
  
  import argparse
  import json
  import os
  
  import fairseq
  import torch
  from fairseq.data import Dictionary
  
  # Register SEW's fairseq modules
  from sew_asapp import tasks  # noqa: F401
  
  from transformers import (
      SEWDConfig,
      SEWDForCTC,
      SEWDModel,
      WavaVecaCTCTokenizer,
      WavaVecaFeatureExtractor,
      WavaVecaProcessor,
      logging,
  )
  
  
  logging.set_verbosity_info()
  lowerCAmelCase__   	=				logging.get_logger(__name__)
  
  lowerCAmelCase__   	=				{
      'post_extract_proj': 'feature_projection',
      'encoder.pos_conv.0': 'encoder.pos_conv_embed.conv',
      'attention.self.query_proj': 'encoder.encoder.layer.*.attention.self.query_proj',
      'attention.self.key_proj': 'encoder.encoder.layer.*.attention.self.key_proj',
      'attention.self.value_proj': 'encoder.encoder.layer.*.attention.self.value_proj',
      'attention.output.dense': 'encoder.encoder.layer.*.attention.output.dense',
      'attention.output.LayerNorm': 'encoder.encoder.layer.*.attention.output.LayerNorm',
      'intermediate.dense': 'encoder.encoder.layer.*.intermediate.dense',
      'output.dense': 'encoder.encoder.layer.*.output.dense',
      'output.LayerNorm': 'encoder.encoder.layer.*.output.LayerNorm',
      'encoder.encoder.rel_embeddings': 'encoder.encoder.rel_embeddings',
      'encoder.encoder.LayerNorm': 'encoder.encoder.LayerNorm',
      'encoder.upsample.0': 'encoder.upsample.projection',
      'encoder.layer_norm': 'encoder.layer_norm',
      'w2v_model.layer_norm': 'layer_norm',
      'w2v_encoder.proj': 'lm_head',
      'mask_emb': 'masked_spec_embed',
  }
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Tuple       ,							UpperCamelCase__  :						Union[str, Any]       ,							UpperCamelCase__  :						Tuple       ,							UpperCamelCase__  :						Dict		):
         for attribute in key.split("."		):
                _A   : Union[str, Any]       					=				getattr(UpperCamelCase__       ,							UpperCamelCase__		)
  
         if weight_type is not None:
                _A   : List[Any]       					=				getattr(UpperCamelCase__       ,							UpperCamelCase__		).shape
         else:
                _A   : Optional[int]       					=				hf_pointer.shape
  
         assert hf_shape == value.shape, (
             f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
             f" {value.shape} for {full_name}"
         )
  
         if weight_type == "weight":
                _A   : Optional[int]       					=				value
         elif weight_type == "weight_g":
                _A   : str       					=				value
         elif weight_type == "weight_v":
                _A   : int       					=				value
         elif weight_type == "bias":
                _A   : Optional[Any]       					=				value
         else:
                _A   : Union[str, Any]       					=				value
  
         logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}."		)
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Any       ,							UpperCamelCase__  :						Any       ,							UpperCamelCase__  :						Any		):
         _A   : Optional[Any]       					=				[]
         _A   : Optional[int]       					=				fairseq_model.state_dict()
  
         _A   : Any       					=				hf_model.sew_d.feature_extractor if is_finetuned else hf_model.feature_extractor
  
         for name, value in fairseq_dict.items():
                _A   : Optional[int]       					=				False
                if "conv_layers" in name:
                       load_conv_layer(
                           UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							hf_model.config.feat_extract_norm == "group"       ,							)
                       _A   : Optional[Any]       					=				True
                else:
                       for key, mapped_key in MAPPING.items():
                              _A   : str       					=				"sew_d." + mapped_key if (is_finetuned and mapped_key != "lm_head") else mapped_key
  
                              if key in name or key.split("w2v_model."		)[-1] == name.split("."		)[0]:
                                     _A   : Dict       					=				True
                                     if "*" in mapped_key:
                                            _A   : Tuple       					=				name.split(UpperCamelCase__		)[0].split("."		)[-2]
                                            if not layer_index.isnumeric():
                                                   continue
                                            _A   : List[Any]       					=				mapped_key.replace("*"       ,							UpperCamelCase__		)
                                     if "weight_g" in name:
                                            _A   : Dict       					=				"weight_g"
                                     elif "weight_v" in name:
                                            _A   : Dict       					=				"weight_v"
                                     elif "weight" in name:
                                            _A   : Optional[int]       					=				"weight"
                                     elif "bias" in name:
                                            _A   : Any       					=				"bias"
                                     else:
                                            _A   : List[str]       					=				None
                                     set_recursively(UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__		)
                              continue
                if not is_used:
                       unused_weights.append(UpperCamelCase__		)
  
         logger.warning(f"Unused weights: {unused_weights}"		)
  def 							_UpperCAmelCase       (UpperCamelCase__  :						List[str]       ,							UpperCamelCase__  :						str       ,							UpperCamelCase__  :						List[Any]       ,							UpperCamelCase__  :						Optional[int]       ,							UpperCamelCase__  :						List[str]		):
         _A   : Any       					=				full_name.split("conv_layers."		)[-1]
         _A   : Union[str, Any]       					=				name.split("."		)
         _A   : Union[str, Any]       					=				int(items[0]		)
         _A   : int       					=				int(items[1]		)
  
         if type_id == 0:
                if "bias" in name:
                       assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
                           f"{full_name} has size {value.shape}, but"
                           f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
                       )
                       _A   : Optional[Any]       					=				value
                       logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}."		)
                elif "weight" in name:
                       assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
                           f"{full_name} has size {value.shape}, but"
                           f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
                       )
                       _A   : Optional[int]       					=				value
                       logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}."		)
         elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
                if "bias" in name:
                       assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
                           f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
                           " found."
                       )
                       _A   : Union[str, Any]       					=				value
                       logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."		)
                elif "weight" in name:
                       assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
                           f"{full_name} has size {value.shape}, but"
                           f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
                       )
                       _A   : int       					=				value
                       logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."		)
         else:
                unused_weights.append(UpperCamelCase__		)
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Tuple       ,							UpperCamelCase__  :						Any		):
         _A   : Any       					=				SEWDConfig()
         if is_finetuned:
                _A   : List[str]       					=				model.wav_encoder.wav_model.cfg
         else:
                _A   : Tuple       					=				model.cfg
  
         _A   : Optional[Any]       					=				fs_config.conv_bias
         _A   : Dict       					=				eval(fs_config.conv_feature_layers		)
         _A   : str       					=				[x[0] for x in conv_layers]
         _A   : List[str]       					=				[x[1] for x in conv_layers]
         _A   : int       					=				[x[2] for x in conv_layers]
         _A   : Optional[Any]       					=				"gelu"
         _A   : Optional[Any]       					=				"layer" if fs_config.extractor_mode == "layer_norm" else "group"
         _A   : List[str]       					=				0.0
         _A   : List[str]       					=				fs_config.activation_fn.name
         _A   : List[Any]       					=				fs_config.encoder_embed_dim
         _A   : Tuple       					=				0.02
         _A   : Any       					=				fs_config.encoder_ffn_embed_dim
         _A   : int       					=				1E-5
         _A   : List[Any]       					=				fs_config.encoder_layerdrop
         _A   : Dict       					=				fs_config.encoder_attention_heads
         _A   : int       					=				fs_config.conv_pos_groups
         _A   : Any       					=				fs_config.conv_pos
         _A   : Optional[int]       					=				len(UpperCamelCase__		)
         _A   : Union[str, Any]       					=				fs_config.encoder_layers
         _A   : List[Any]       					=				fs_config.squeeze_factor
         # DeBERTa-specific parameters:
         _A   : List[Any]       					=				fs_config.max_position_embeddings
         _A   : int       					=				fs_config.position_buckets
         _A   : Optional[int]       					=				fs_config.share_att_key
         _A   : str       					=				fs_config.relative_attention
         _A   : Union[str, Any]       					=				fs_config.position_biased_input
         _A   : Optional[Any]       					=				tuple(fs_config.pos_att_type.split("|"		)		)
         _A   : str       					=				fs_config.norm_rel_ebd
  
         # take care of any params that are overridden by the Wav2VecCtc model
         if is_finetuned:
                _A   : Tuple       					=				model.cfg
                _A   : Union[str, Any]       					=				fs_config.final_dropout
                _A   : List[Any]       					=				fs_config.layerdrop
         _A   : List[Any]       					=				fs_config.activation_dropout
         _A   : Optional[int]       					=				fs_config.mask_prob > 0 or fs_config.mask_channel_prob > 0
         _A   : Any       					=				fs_config.attention_dropout
         _A   : Dict       					=				fs_config.dropout_input
         _A   : List[str]       					=				fs_config.dropout
         _A   : Tuple       					=				fs_config.mask_channel_length
         _A   : Optional[int]       					=				fs_config.mask_channel_prob
         _A   : List[Any]       					=				fs_config.mask_length
         _A   : Tuple       					=				fs_config.mask_prob
  
         _A   : Dict       					=				"Wav2Vec2FeatureExtractor"
         _A   : List[str]       					=				"Wav2Vec2CTCTokenizer"
  
         return config
  @torch.no_grad()
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Any       ,							UpperCamelCase__  :						List[Any]       ,							UpperCamelCase__  :						Tuple=None       ,							UpperCamelCase__  :						Union[str, Any]=None       ,							UpperCamelCase__  :						List[Any]=True		):
  
         if is_finetuned:
                _A					,    _A					,    _A   : Dict       					=				fairseq.checkpoint_utils.load_model_ensemble_and_task(
                    [checkpoint_path]       ,							arg_overrides={"data": "/".join(dict_path.split("/"		)[:-1]		)}		)
         else:
                _A					,    _A					,    _A   : List[Any]       					=				fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]		)
  
         if config_path is not None:
                _A   : Dict       					=				SEWDConfig.from_pretrained(UpperCamelCase__		)
         else:
                _A   : Optional[int]       					=				convert_config(model[0]       ,							UpperCamelCase__		)
         _A   : Any       					=				model[0].eval()
  
         _A   : Tuple       					=				True if config.feat_extract_norm == "layer" else False
         _A   : List[str]       					=				WavaVecaFeatureExtractor(
             feature_size=1       ,							sampling_rate=16000       ,							padding_value=0       ,							do_normalize=UpperCamelCase__       ,							return_attention_mask=UpperCamelCase__       ,							)
  
         if is_finetuned:
                if dict_path:
                       _A   : Tuple       					=				Dictionary.load(UpperCamelCase__		)
  
                       # important change bos & pad token id since CTC symbol is <pad> and
                       # not <s> as in fairseq
                       _A   : List[str]       					=				target_dict.pad_index
                       _A   : Dict       					=				target_dict.bos_index
                       _A   : Union[str, Any]       					=				target_dict.pad_index
                       _A   : str       					=				target_dict.bos_index
                       _A   : Any       					=				target_dict.eos_index
                       _A   : Any       					=				len(target_dict.symbols		)
                       _A   : Tuple       					=				os.path.join(UpperCamelCase__       ,							"vocab.json"		)
                       if not os.path.isdir(UpperCamelCase__		):
                              logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(UpperCamelCase__		)		)
                              return
                       os.makedirs(UpperCamelCase__       ,							exist_ok=UpperCamelCase__		)
                       with open(UpperCamelCase__       ,							"w"       ,							encoding="utf-8"		) as vocab_handle:
                              json.dump(target_dict.indices       ,							UpperCamelCase__		)
                       _A   : int       					=				WavaVecaCTCTokenizer(
                           UpperCamelCase__       ,							unk_token=target_dict.unk_word       ,							pad_token=target_dict.pad_word       ,							bos_token=target_dict.bos_word       ,							eos_token=target_dict.eos_word       ,							word_delimiter_token="|"       ,							do_lower_case=UpperCamelCase__       ,							)
                       _A   : List[Any]       					=				WavaVecaProcessor(feature_extractor=UpperCamelCase__       ,							tokenizer=UpperCamelCase__		)
                       processor.save_pretrained(UpperCamelCase__		)
  
                _A   : Dict       					=				SEWDForCTC(UpperCamelCase__		)
         else:
                _A   : Any       					=				SEWDModel(UpperCamelCase__		)
                feature_extractor.save_pretrained(UpperCamelCase__		)
  
         recursively_load_weights(UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__		)
  
         hf_model.save_pretrained(UpperCamelCase__		)
  
  
  if __name__ == "__main__":
      lowerCAmelCase__   	=				argparse.ArgumentParser()
      parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
      parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to fairseq checkpoint')
      parser.add_argument('--dict_path', default=None, type=str, help='Path to dict of fine-tuned model')
      parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
      parser.add_argument(
          '--is_finetuned', action='store_true', help='Whether the model to convert is a fine-tuned model or not'
      )
      lowerCAmelCase__   	=				parser.parse_args()
      convert_sew_checkpoint(
          args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, args.is_finetuned
      )
  
style_context: 
  
  
  import cva
  import numpy as np
  
  from digital_image_processing.filters.convolve import img_convolve
  from digital_image_processing.filters.sobel_filter import sobel_filter
  
  lowerCAmelCase__   	=				1_80
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Optional[Any]		):
         _A   : int       					=				k_size // 2
         _A					,    _A   : Tuple       					=				np.mgrid[0 - center : k_size - center, 0 - center : k_size - center]
         _A   : Union[str, Any]       					=				(
             1
             / (2 * np.pi * sigma)
             * np.exp(-(np.square(UpperCamelCase__		) + np.square(UpperCamelCase__		)) / (2 * np.square(UpperCamelCase__		))		)
         )
         return g
  def 							_UpperCAmelCase       (UpperCamelCase__  :						str       ,							UpperCamelCase__  :						Any       ,							UpperCamelCase__  :						Tuple		):
         _A   : Optional[int]       					=				np.zeros(UpperCamelCase__		)
  
         for row in range(1       ,							image_shape[0] - 1		):
                for col in range(1       ,							image_shape[1] - 1		):
                       _A   : Dict       					=				gradient_direction[row, col]
  
                       if (
                           0 <= direction < PI / 8
                           or 15 * PI / 8 <= direction <= 2 * PI
                           or 7 * PI / 8 <= direction <= 9 * PI / 8
                       ):
                              _A   : Dict       					=				sobel_grad[row, col - 1]
                              _A   : Any       					=				sobel_grad[row, col + 1]
                              if sobel_grad[row, col] >= w and sobel_grad[row, col] >= e:
                                     _A   : List[Any]       					=				sobel_grad[row, col]
  
                       elif (
                           PI / 8 <= direction < 3 * PI / 8
                           or 9 * PI / 8 <= direction < 11 * PI / 8
                       ):
                              _A   : List[str]       					=				sobel_grad[row + 1, col - 1]
                              _A   : str       					=				sobel_grad[row - 1, col + 1]
                              if sobel_grad[row, col] >= sw and sobel_grad[row, col] >= ne:
                                     _A   : List[Any]       					=				sobel_grad[row, col]
  
                       elif (
                           3 * PI / 8 <= direction < 5 * PI / 8
                           or 11 * PI / 8 <= direction < 13 * PI / 8
                       ):
                              _A   : Any       					=				sobel_grad[row - 1, col]
                              _A   : int       					=				sobel_grad[row + 1, col]
                              if sobel_grad[row, col] >= n and sobel_grad[row, col] >= s:
                                     _A   : Any       					=				sobel_grad[row, col]
  
                       elif (
                           5 * PI / 8 <= direction < 7 * PI / 8
                           or 13 * PI / 8 <= direction < 15 * PI / 8
                       ):
                              _A   : List[str]       					=				sobel_grad[row - 1, col - 1]
                              _A   : Optional[Any]       					=				sobel_grad[row + 1, col + 1]
                              if sobel_grad[row, col] >= nw and sobel_grad[row, col] >= se:
                                     _A   : List[Any]       					=				sobel_grad[row, col]
  
         return destination
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Dict       ,							UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						str       ,							UpperCamelCase__  :						Dict       ,							UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Any		):
         for row in range(1       ,							image_shape[0] - 1		):
                for col in range(1       ,							image_shape[1] - 1		):
                       if destination[row, col] >= threshold_high:
                              _A   : Optional[int]       					=				strong
                       elif destination[row, col] <= threshold_low:
                              _A   : Optional[int]       					=				0
                       else:
                              _A   : Union[str, Any]       					=				weak
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Optional[int]       ,							UpperCamelCase__  :						Any       ,							UpperCamelCase__  :						Any		):
         for row in range(1       ,							image_shape[0]		):
                for col in range(1       ,							image_shape[1]		):
                       if destination[row, col] == weak:
                              if 255 in (
                                  destination[row, col + 1],
                                  destination[row, col - 1],
                                  destination[row - 1, col],
                                  destination[row + 1, col],
                                  destination[row - 1, col - 1],
                                  destination[row + 1, col - 1],
                                  destination[row - 1, col + 1],
                                  destination[row + 1, col + 1],
                              ):
                                     _A   : str       					=				strong
                              else:
                                     _A   : Any       					=				0
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Dict       ,							UpperCamelCase__  :						int=15       ,							UpperCamelCase__  :						Dict=30       ,							UpperCamelCase__  :						int=128       ,							UpperCamelCase__  :						Union[str, Any]=255		):
         # gaussian_filter
         _A   : Union[str, Any]       					=				img_convolve(UpperCamelCase__       ,							gen_gaussian_kernel(9       ,							sigma=1.4		)		)
         # get the gradient and degree by sobel_filter
         _A					,    _A   : Dict       					=				sobel_filter(UpperCamelCase__		)
         _A   : Tuple       					=				PI + np.radadeg(UpperCamelCase__		)
  
         _A   : Optional[int]       					=				suppress_non_maximum(image.shape       ,							UpperCamelCase__       ,							UpperCamelCase__		)
  
         detect_high_low_threshold(
             image.shape       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__		)
  
         track_edge(image.shape       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__		)
  
         return destination
  
  
  if __name__ == "__main__":
      # read original image in gray mode
      lowerCAmelCase__   	=				cva.imread(R'../image_data/lena.jpg', 0)
      # canny edge detection
      lowerCAmelCase__   	=				canny(lena)
      cva.imshow('canny', canny_destination)
      cva.waitKey(0)
  