"""simple docstring"""




import argparse
import json
from pathlib import Path

import requests
import timm
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import AutoImageProcessor, SwinvaConfig, SwinvaForImageClassification





def 							SCREAMING_SNAKE_CASE     (			_lowerCamelCase						:       List[str]	)       ->      int:
  _lowerCAmelCase						:       Tuple  			=     SwinvaConfig()
  _lowerCAmelCase						:       List[str]  			=     swinva_name.split("""_"""	)

  _lowerCAmelCase						:       str  			=     name_split[1]
  if "to" in name_split[3]:
    _lowerCAmelCase						:       Optional[int]  			=     int(name_split[3][-3:]	)
  else:
    _lowerCAmelCase						:       Optional[Any]  			=     int(name_split[3]	)
  if "to" in name_split[2]:
    _lowerCAmelCase						:       Optional[int]  			=     int(name_split[2][-2:]	)
  else:
    _lowerCAmelCase						:       Tuple  			=     int(name_split[2][6:]	)

  if model_size == "tiny":
    _lowerCAmelCase						:       Optional[Any]  			=     96
    _lowerCAmelCase						:       Optional[int]  			=     (2, 2, 6, 2)
    _lowerCAmelCase						:       Tuple  			=     (3, 6, 12, 24)
  elif model_size == "small":
    _lowerCAmelCase						:       int  			=     96
    _lowerCAmelCase						:       Tuple  			=     (2, 2, 18, 2)
    _lowerCAmelCase						:       Optional[int]  			=     (3, 6, 12, 24)
  elif model_size == "base":
    _lowerCAmelCase						:       List[Any]  			=     128
    _lowerCAmelCase						:       Optional[int]  			=     (2, 2, 18, 2)
    _lowerCAmelCase						:       Tuple  			=     (4, 8, 16, 32)
  else:
    _lowerCAmelCase						:       Dict  			=     192
    _lowerCAmelCase						:       Union[str, Any]  			=     (2, 2, 18, 2)
    _lowerCAmelCase						:       str  			=     (6, 12, 24, 48)

  if "to" in swinva_name:
    _lowerCAmelCase						:       Dict  			=     (12, 12, 12, 6)

  if ("22k" in swinva_name) and ("to" not in swinva_name):
    _lowerCAmelCase						:       Optional[Any]  			=     21841
    _lowerCAmelCase						:       str  			=     """huggingface/label-files"""
    _lowerCAmelCase						:       str  			=     """imagenet-22k-id2label.json"""
    _lowerCAmelCase						:       List[str]  			=     json.load(open(hf_hub_download(_lowerCamelCase			,_lowerCamelCase			,repo_type="""dataset"""	)			,"""r"""	)	)
    _lowerCAmelCase						:       List[Any]  			=     {int(_lowerCamelCase	): v for k, v in idalabel.items()}
    _lowerCAmelCase						:       int  			=     idalabel
    _lowerCAmelCase						:       Tuple  			=     {v: k for k, v in idalabel.items()}

  else:
    _lowerCAmelCase						:       Union[str, Any]  			=     1000
    _lowerCAmelCase						:       List[Any]  			=     """huggingface/label-files"""
    _lowerCAmelCase						:       Optional[int]  			=     """imagenet-1k-id2label.json"""
    _lowerCAmelCase						:       Optional[Any]  			=     json.load(open(hf_hub_download(_lowerCamelCase			,_lowerCamelCase			,repo_type="""dataset"""	)			,"""r"""	)	)
    _lowerCAmelCase						:       Tuple  			=     {int(_lowerCamelCase	): v for k, v in idalabel.items()}
    _lowerCAmelCase						:       int  			=     idalabel
    _lowerCAmelCase						:       List[str]  			=     {v: k for k, v in idalabel.items()}

  _lowerCAmelCase						:       int  			=     img_size
  _lowerCAmelCase						:       Optional[Any]  			=     num_classes
  _lowerCAmelCase						:       List[str]  			=     embed_dim
  _lowerCAmelCase						:       Any  			=     depths
  _lowerCAmelCase						:       List[Any]  			=     num_heads
  _lowerCAmelCase						:       Optional[Any]  			=     window_size

  return config





def 							SCREAMING_SNAKE_CASE     (			_lowerCamelCase						:       Optional[Any]	)       ->      Tuple:
  if "patch_embed.proj" in name:
    _lowerCAmelCase						:       int  			=     name.replace("""patch_embed.proj"""			,"""embeddings.patch_embeddings.projection"""	)
  if "patch_embed.norm" in name:
    _lowerCAmelCase						:       Any  			=     name.replace("""patch_embed.norm"""			,"""embeddings.norm"""	)
  if "layers" in name:
    _lowerCAmelCase						:       Any  			=     """encoder.""" + name
  if "attn.proj" in name:
    _lowerCAmelCase						:       int  			=     name.replace("""attn.proj"""			,"""attention.output.dense"""	)
  if "attn" in name:
    _lowerCAmelCase						:       List[Any]  			=     name.replace("""attn"""			,"""attention.self"""	)
  if "norm1" in name:
    _lowerCAmelCase						:       Union[str, Any]  			=     name.replace("""norm1"""			,"""layernorm_before"""	)
  if "norm2" in name:
    _lowerCAmelCase						:       Any  			=     name.replace("""norm2"""			,"""layernorm_after"""	)
  if "mlp.fc1" in name:
    _lowerCAmelCase						:       List[Any]  			=     name.replace("""mlp.fc1"""			,"""intermediate.dense"""	)
  if "mlp.fc2" in name:
    _lowerCAmelCase						:       str  			=     name.replace("""mlp.fc2"""			,"""output.dense"""	)
  if "q_bias" in name:
    _lowerCAmelCase						:       Union[str, Any]  			=     name.replace("""q_bias"""			,"""query.bias"""	)
  if "k_bias" in name:
    _lowerCAmelCase						:       Any  			=     name.replace("""k_bias"""			,"""key.bias"""	)
  if "v_bias" in name:
    _lowerCAmelCase						:       Dict  			=     name.replace("""v_bias"""			,"""value.bias"""	)
  if "cpb_mlp" in name:
    _lowerCAmelCase						:       List[Any]  			=     name.replace("""cpb_mlp"""			,"""continuous_position_bias_mlp"""	)
  if name == "norm.weight":
    _lowerCAmelCase						:       Optional[int]  			=     """layernorm.weight"""
  if name == "norm.bias":
    _lowerCAmelCase						:       Optional[Any]  			=     """layernorm.bias"""

  if "head" in name:
    _lowerCAmelCase						:       List[str]  			=     name.replace("""head"""			,"""classifier"""	)
  else:
    _lowerCAmelCase						:       Optional[int]  			=     """swinv2.""" + name

  return name





def 							SCREAMING_SNAKE_CASE     (			_lowerCamelCase						:       Optional[int]			,_lowerCamelCase						:       List[Any]	)       ->      Union[str, Any]:
  for key in orig_state_dict.copy().keys():
    _lowerCAmelCase						:       Any  			=     orig_state_dict.pop(_lowerCamelCase	)

    if "mask" in key:
      continue
    elif "qkv" in key:
      _lowerCAmelCase						:       Union[str, Any]  			=     key.split("""."""	)
      _lowerCAmelCase						:       List[str]  			=     int(key_split[1]	)
      _lowerCAmelCase						:       List[str]  			=     int(key_split[3]	)
      _lowerCAmelCase						:       Union[str, Any]  			=     model.swinva.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size

      if "weight" in key:
        _lowerCAmelCase						:       Tuple  			=     val[:dim, :]
        _lowerCAmelCase						:       Any  			=     val[dim : dim * 2, :]
        _lowerCAmelCase						:       Any  			=     val[-dim:, :]
      else:
        _lowerCAmelCase						:       Optional[int]  			=     val[:dim]
        _lowerCAmelCase						:       int  			=     val[
            dim : dim * 2
        ]
        _lowerCAmelCase						:       List[Any]  			=     val[-dim:]
    else:
      _lowerCAmelCase						:       int  			=     val

  return orig_state_dict





def 							SCREAMING_SNAKE_CASE     (			_lowerCamelCase						:       Tuple			,_lowerCamelCase						:       Union[str, Any]	)       ->      Dict:
  _lowerCAmelCase						:       str  			=     timm.create_model(_lowerCamelCase			,pretrained=_lowerCamelCase	)
  timm_model.eval()

  _lowerCAmelCase						:       Union[str, Any]  			=     get_swinva_config(_lowerCamelCase	)
  _lowerCAmelCase						:       Optional[Any]  			=     SwinvaForImageClassification(_lowerCamelCase	)
  model.eval()

  _lowerCAmelCase						:       List[str]  			=     convert_state_dict(timm_model.state_dict()			,_lowerCamelCase	)
  model.load_state_dict(_lowerCamelCase	)

  _lowerCAmelCase						:       int  			=     """http://images.cocodataset.org/val2017/000000039769.jpg"""

  _lowerCAmelCase						:       Tuple  			=     AutoImageProcessor.from_pretrained("""microsoft/{}""".format(swinva_name.replace("""_"""			,"""-"""	)	)	)
  _lowerCAmelCase						:       str  			=     Image.open(requests.get(_lowerCamelCase			,stream=_lowerCamelCase	).raw	)
  _lowerCAmelCase						:       int  			=     image_processor(images=_lowerCamelCase			,return_tensors="""pt"""	)

  _lowerCAmelCase						:       Optional[Any]  			=     timm_model(inputs["""pixel_values"""]	)
  _lowerCAmelCase						:       Tuple  			=     model(**_lowerCamelCase	).logits

  assert torch.allclose(_lowerCamelCase			,_lowerCamelCase			,atol=1e-3	)

  print(f"Saving model {swinva_name} to {pytorch_dump_folder_path}"	)
  model.save_pretrained(_lowerCamelCase	)

  print(f"Saving image processor to {pytorch_dump_folder_path}"	)
  image_processor.save_pretrained(_lowerCamelCase	)

  model.push_to_hub(
      repo_path_or_name=Path(_lowerCamelCase			,_lowerCamelCase	)			,organization="""nandwalritik"""			,commit_message="""Add model"""			,)


if __name__ == "__main__":
     _a      :		Optional[Any]           =   argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '--swinv2_name',
         default='swinv2_tiny_patch4_window8_256',
         type=str,
         help='Name of the Swinv2 timm 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.'
     )

     _a      :		Dict           =   parser.parse_args()
     convert_swinva_checkpoint(args.swinva_name, args.pytorch_dump_folder_path)





"""simple docstring"""




import unittest

from transformers import DebertaVaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         DebertaVaForMaskedLM,
         DebertaVaForMultipleChoice,
         DebertaVaForQuestionAnswering,
         DebertaVaForSequenceClassification,
         DebertaVaForTokenClassification,
         DebertaVaModel,
     )
     from transformers.models.deberta_va.modeling_deberta_va import DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST
class 						__A							( SCREAMING_SNAKE_CASE_		):






     def __init__(		self				,     a__				,     a__=13				,     a__=7				,     a__=True				,     a__=True				,     a__=True				,     a__=True				,     a__=99				,     a__=32				,     a__=5				,     a__=4				,     a__=37				,     a__="gelu"				,     a__=0.1				,     a__=0.1				,     a__=512				,     a__=16				,     a__=2				,     a__=0.0_2				,     a__=False				,     a__=True				,     a__="None"				,     a__=3				,     a__=4				,     a__=None				,     ):
       _lowerCAmelCase						:       Dict  			=     parent
       _lowerCAmelCase						:       str  			=     batch_size
       _lowerCAmelCase						:       List[Any]  			=     seq_length
       _lowerCAmelCase						:       Dict  			=     is_training
       _lowerCAmelCase						:       Dict  			=     use_input_mask
       _lowerCAmelCase						:       int  			=     use_token_type_ids
       _lowerCAmelCase						:       int  			=     use_labels
       _lowerCAmelCase						:       Optional[int]  			=     vocab_size
       _lowerCAmelCase						:       Tuple  			=     hidden_size
       _lowerCAmelCase						:       Tuple  			=     num_hidden_layers
       _lowerCAmelCase						:       Dict  			=     num_attention_heads
       _lowerCAmelCase						:       Union[str, Any]  			=     intermediate_size
       _lowerCAmelCase						:       str  			=     hidden_act
       _lowerCAmelCase						:       Any  			=     hidden_dropout_prob
       _lowerCAmelCase						:       List[str]  			=     attention_probs_dropout_prob
       _lowerCAmelCase						:       List[str]  			=     max_position_embeddings
       _lowerCAmelCase						:       List[str]  			=     type_vocab_size
       _lowerCAmelCase						:       Tuple  			=     type_sequence_label_size
       _lowerCAmelCase						:       List[Any]  			=     initializer_range
       _lowerCAmelCase						:       Union[str, Any]  			=     num_labels
       _lowerCAmelCase						:       Optional[Any]  			=     num_choices
       _lowerCAmelCase						:       Tuple  			=     relative_attention
       _lowerCAmelCase						:       Tuple  			=     position_biased_input
       _lowerCAmelCase						:       Dict  			=     pos_att_type
       _lowerCAmelCase						:       Any  			=     scope






     def     __A  (		self  ):
       _lowerCAmelCase						:       int  			=     ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size  )

       _lowerCAmelCase						:       Optional[Any]  			=     None
       if self.use_input_mask:
         _lowerCAmelCase						:       str  			=     ids_tensor([self.batch_size, self.seq_length]				,     vocab_size=2  )

       _lowerCAmelCase						:       str  			=     None
       if self.use_token_type_ids:
         _lowerCAmelCase						:       List[str]  			=     ids_tensor([self.batch_size, self.seq_length]				,     self.type_vocab_size  )

       _lowerCAmelCase						:       Union[str, Any]  			=     None
       _lowerCAmelCase						:       Union[str, Any]  			=     None
       _lowerCAmelCase						:       Any  			=     None
       if self.use_labels:
         _lowerCAmelCase						:       str  			=     ids_tensor([self.batch_size]				,     self.type_sequence_label_size  )
         _lowerCAmelCase						:       int  			=     ids_tensor([self.batch_size, self.seq_length]				,     self.num_labels  )
         _lowerCAmelCase						:       str  			=     ids_tensor([self.batch_size]				,     self.num_choices  )

       _lowerCAmelCase						:       List[str]  			=     self.get_config()

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






     def     __A  (		self  ):
       return DebertaVaConfig(
           vocab_size=self.vocab_size				,     hidden_size=self.hidden_size				,     num_hidden_layers=self.num_hidden_layers				,     num_attention_heads=self.num_attention_heads				,     intermediate_size=self.intermediate_size				,     hidden_act=self.hidden_act				,     hidden_dropout_prob=self.hidden_dropout_prob				,     attention_probs_dropout_prob=self.attention_probs_dropout_prob				,     max_position_embeddings=self.max_position_embeddings				,     type_vocab_size=self.type_vocab_size				,     initializer_range=self.initializer_range				,     relative_attention=self.relative_attention				,     position_biased_input=self.position_biased_input				,     pos_att_type=self.pos_att_type				,     )






     def     __A  (		self				,     a__  ):
       self.parent.assertListEqual(list(result.loss.size()  )				,     []  )






     def     __A  (		self				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__  ):
       _lowerCAmelCase						:       Union[str, Any]  			=     DebertaVaModel(config=a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:       List[Any]  			=     model(a__				,     attention_mask=a__				,     token_type_ids=a__  )[0]
       _lowerCAmelCase						:       List[Any]  			=     model(a__				,     token_type_ids=a__  )[0]
       _lowerCAmelCase						:       Any  			=     model(a__  )[0]

       self.parent.assertListEqual(list(sequence_output.size()  )				,     [self.batch_size, self.seq_length, self.hidden_size]  )






     def     __A  (		self				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__  ):
       _lowerCAmelCase						:       List[str]  			=     DebertaVaForMaskedLM(config=a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:       Optional[Any]  			=     model(a__				,     attention_mask=a__				,     token_type_ids=a__				,     labels=a__  )

       self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.vocab_size)  )






     def     __A  (		self				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__  ):
       _lowerCAmelCase						:       int  			=     self.num_labels
       _lowerCAmelCase						:       int  			=     DebertaVaForSequenceClassification(a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:       Optional[Any]  			=     model(a__				,     attention_mask=a__				,     token_type_ids=a__				,     labels=a__  )
       self.parent.assertListEqual(list(result.logits.size()  )				,     [self.batch_size, self.num_labels]  )
       self.check_loss_output(a__  )






     def     __A  (		self				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__  ):
       _lowerCAmelCase						:       List[Any]  			=     self.num_labels
       _lowerCAmelCase						:       str  			=     DebertaVaForTokenClassification(config=a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:       Optional[Any]  			=     model(a__				,     attention_mask=a__				,     token_type_ids=a__				,     labels=a__  )
       self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.num_labels)  )






     def     __A  (		self				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__  ):
       _lowerCAmelCase						:       Any  			=     DebertaVaForQuestionAnswering(config=a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:       Dict  			=     model(
           a__				,     attention_mask=a__				,     token_type_ids=a__				,     start_positions=a__				,     end_positions=a__				,     )
       self.parent.assertEqual(result.start_logits.shape				,     (self.batch_size, self.seq_length)  )
       self.parent.assertEqual(result.end_logits.shape				,     (self.batch_size, self.seq_length)  )






     def     __A  (		self				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__  ):
       _lowerCAmelCase						:       Union[str, Any]  			=     DebertaVaForMultipleChoice(config=a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:       Optional[int]  			=     input_ids.unsqueeze(1  ).expand(-1				,     self.num_choices				,     -1  ).contiguous()
       _lowerCAmelCase						:       Optional[Any]  			=     token_type_ids.unsqueeze(1  ).expand(-1				,     self.num_choices				,     -1  ).contiguous()
       _lowerCAmelCase						:       str  			=     input_mask.unsqueeze(1  ).expand(-1				,     self.num_choices				,     -1  ).contiguous()
       _lowerCAmelCase						:       List[str]  			=     model(
           a__				,     attention_mask=a__				,     token_type_ids=a__				,     labels=a__				,     )
       self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_choices)  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       Tuple  			=     self.prepare_config_and_inputs()
       (
           (
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	
       )						:       Union[str, Any]  			=     config_and_inputs
       _lowerCAmelCase						:       Union[str, Any]  			=     {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
       return config, inputs_dict







@require_torch
class 						__A							( SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_    ,	unittest.TestCase		):
     _UpperCamelCase							:			Union[str, Any]							=		(
         (
             DebertaVaModel,
             DebertaVaForMaskedLM,
             DebertaVaForSequenceClassification,
             DebertaVaForTokenClassification,
             DebertaVaForQuestionAnswering,
             DebertaVaForMultipleChoice,
         )
         if is_torch_available()
         else ()
     )
     _UpperCamelCase							:			str							=		(
         {
             "feature-extraction": DebertaVaModel,
             "fill-mask": DebertaVaForMaskedLM,
             "question-answering": DebertaVaForQuestionAnswering,
             "text-classification": DebertaVaForSequenceClassification,
             "token-classification": DebertaVaForTokenClassification,
             "zero-shot": DebertaVaForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )

     _UpperCamelCase							:			Optional[Any]							=		True
     _UpperCamelCase							:			List[Any]							=		False
     _UpperCamelCase							:			List[Any]							=		False
     _UpperCamelCase							:			Dict							=		False
     _UpperCamelCase							:			Tuple							=		False






     def     __A  (		self  ):
       _lowerCAmelCase						:       Optional[Any]  			=     DebertaVaModelTester(self  )
       _lowerCAmelCase						:       Any  			=     ConfigTester(self				,     config_class=a__				,     hidden_size=37  )






     def     __A  (		self  ):
       self.config_tester.run_common_tests()






     def     __A  (		self  ):
       _lowerCAmelCase						:       Optional[int]  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_model(*a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       List[str]  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_sequence_classification(*a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       Any  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_masked_lm(*a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       List[Any]  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_question_answering(*a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       List[Any]  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_token_classification(*a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       Union[str, Any]  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_multiple_choice(*a__  )






     @slow
     def     __A  (		self  ):
       for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowerCAmelCase						:       Tuple  			=     DebertaVaModel.from_pretrained(a__  )
         self.assertIsNotNone(a__  )







@require_torch
@require_sentencepiece
@require_tokenizers
class 						__A							( unittest.TestCase		):






     @unittest.skip(reason="""Model not available yet"""  )
     def     __A  (		self  ):
       pass






     @slow
     def     __A  (		self  ):
       _lowerCAmelCase						:       Union[str, Any]  			=     DebertaVaModel.from_pretrained("""microsoft/deberta-v2-xlarge"""  )

       _lowerCAmelCase						:       Dict  			=     torch.tensor([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]  )
       _lowerCAmelCase						:       Any  			=     torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
       with torch.no_grad():
         _lowerCAmelCase						:       Optional[Any]  			=     model(a__				,     attention_mask=a__  )[0]
       # compare the actual values for a slice.
       _lowerCAmelCase						:       str  			=     torch.tensor(
           [[[0.2_3_5_6, 0.1_9_4_8, 0.0_3_6_9], [-0.1_0_6_3, 0.3_5_8_6, -0.5_1_5_2], [-0.6_3_9_9, -0.0_2_5_9, -0.2_5_2_5]]]  )
       self.assertTrue(torch.allclose(output[:, 1:4, 1:4]				,     a__				,     atol=1e-4  )				,     F"{output[:, 1:4, 1:4]}"  )




