





'''simple docstring'''

import json
import os
import shutil
import tempfile
from unittest import TestCase

from transformers import BartTokenizer, BartTokenizerFast, DPRQuestionEncoderTokenizer, DPRQuestionEncoderTokenizerFast
from transformers.models.bart.configuration_bart import BartConfig
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES as DPR_VOCAB_FILES_NAMES
from transformers.models.dpr.configuration_dpr import DPRConfig
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES as BART_VOCAB_FILES_NAMES
from transformers.testing_utils import require_faiss, require_tokenizers, require_torch, slow
from transformers.utils import is_datasets_available, is_faiss_available, is_torch_available


if is_torch_available() and is_datasets_available() and is_faiss_available():
   from transformers.models.rag.configuration_rag import RagConfig
   from transformers.models.rag.tokenization_rag import RagTokenizer





@require_faiss
@require_torch
class lowerCamelCase						(a__					):







  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        _snake_case		:	Union[str, Any]					     =     tempfile.mkdtemp()
        _snake_case		:	Union[str, Any]					     =     8

        # DPR tok
        _snake_case		:	Dict					     =     [
            '''[UNK]''',
            '''[CLS]''',
            '''[SEP]''',
            '''[PAD]''',
            '''[MASK]''',
            '''want''',
            '''##want''',
            '''##ed''',
            '''wa''',
            '''un''',
            '''runn''',
            '''##ing''',
            ''',''',
            '''low''',
            '''lowest''',
        ]
        _snake_case		:	List[Any]					     =     os.path.join(self.tmpdirname     ,     '''dpr_tokenizer'''		)
        os.makedirs(lowercase__     ,     exist_ok=lowercase__		)
        _snake_case		:	Union[str, Any]					     =     os.path.join(lowercase__     ,     DPR_VOCAB_FILES_NAMES['''vocab_file''']		)
        with open(self.vocab_file     ,     '''w'''     ,     encoding='''utf-8'''		) as vocab_writer:
              vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]		)		)

        # BART tok
        _snake_case		:	Optional[int]					     =     [
            '''l''',
            '''o''',
            '''w''',
            '''e''',
            '''r''',
            '''s''',
            '''t''',
            '''i''',
            '''d''',
            '''n''',
            '''\u0120''',
            '''\u0120l''',
            '''\u0120n''',
            '''\u0120lo''',
            '''\u0120low''',
            '''er''',
            '''\u0120lowest''',
            '''\u0120newer''',
            '''\u0120wider''',
            '''<unk>''',
        ]
        _snake_case		:	str					     =     dict(zip(lowercase__     ,     range(len(lowercase__		)		)		)		)
        _snake_case		:	Optional[int]					     =     ['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
        _snake_case		:	str					     =     {'''unk_token''': '''<unk>'''}

        _snake_case		:	Union[str, Any]					     =     os.path.join(self.tmpdirname     ,     '''bart_tokenizer'''		)
        os.makedirs(lowercase__     ,     exist_ok=lowercase__		)
        _snake_case		:	Dict					     =     os.path.join(lowercase__     ,     BART_VOCAB_FILES_NAMES['''vocab_file''']		)
        _snake_case		:	List[str]					     =     os.path.join(lowercase__     ,     BART_VOCAB_FILES_NAMES['''merges_file''']		)
        with open(self.vocab_file     ,     '''w'''     ,     encoding='''utf-8'''		) as fp:
              fp.write(json.dumps(lowercase__		) + '''\n'''		)
        with open(self.merges_file     ,     '''w'''     ,     encoding='''utf-8'''		) as fp:
              fp.write('''\n'''.join(lowercase__		)		)







  def 				UpperCAmelCase_				(		self		)		->						DPRQuestionEncoderTokenizer:






        """simple docstring"""





        return DPRQuestionEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname     ,     '''dpr_tokenizer'''		)		)







  def 				UpperCAmelCase_				(		self		)		->						BartTokenizer:






        """simple docstring"""





        return BartTokenizer.from_pretrained(os.path.join(self.tmpdirname     ,     '''bart_tokenizer'''		)		)







  def 				UpperCAmelCase_				(		self		)		->						List[Any]:






        """simple docstring"""





        shutil.rmtree(self.tmpdirname		)







  @require_tokenizers
  def 				UpperCAmelCase_				(		self		)		->						Any:






        """simple docstring"""





        _snake_case		:	List[str]					     =     os.path.join(self.tmpdirname     ,     '''rag_tokenizer'''		)
        _snake_case		:	Optional[Any]					     =     RagConfig(question_encoder=DPRConfig().to_dict()     ,     generator=BartConfig().to_dict()		)
        _snake_case		:	int					     =     RagTokenizer(question_encoder=self.get_dpr_tokenizer()     ,     generator=self.get_bart_tokenizer()		)
        rag_config.save_pretrained(lowercase__		)
        rag_tokenizer.save_pretrained(lowercase__		)
        _snake_case		:	Optional[Any]					     =     RagTokenizer.from_pretrained(lowercase__     ,     config=lowercase__		)
        self.assertIsInstance(new_rag_tokenizer.question_encoder     ,     lowercase__		)
        self.assertEqual(new_rag_tokenizer.question_encoder.get_vocab()     ,     rag_tokenizer.question_encoder.get_vocab()		)
        self.assertIsInstance(new_rag_tokenizer.generator     ,     lowercase__		)
        self.assertEqual(new_rag_tokenizer.generator.get_vocab()     ,     rag_tokenizer.generator.get_vocab()		)







  @slow
  def 				UpperCAmelCase_				(		self		)		->						List[str]:






        """simple docstring"""





        _snake_case		:	Union[str, Any]					     =     RagTokenizer.from_pretrained('''facebook/rag-token-nq'''		)
        _snake_case		:	int					     =     [
            '''who got the first nobel prize in physics''',
            '''when is the next deadpool movie being released''',
            '''which mode is used for short wave broadcast service''',
            '''who is the owner of reading football club''',
            '''when is the next scandal episode coming out''',
            '''when is the last time the philadelphia won the superbowl''',
            '''what is the most current adobe flash player version''',
            '''how many episodes are there in dragon ball z''',
            '''what is the first step in the evolution of the eye''',
            '''where is gall bladder situated in human body''',
            '''what is the main mineral in lithium batteries''',
            '''who is the president of usa right now''',
            '''where do the greasers live in the outsiders''',
            '''panda is a national animal of which country''',
            '''what is the name of manchester united stadium''',
        ]
        _snake_case		:	Optional[Any]					     =     tokenizer(lowercase__		)
        self.assertIsNotNone(lowercase__		)







  @slow
  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        _snake_case		:	Optional[Any]					     =     RagTokenizer.from_pretrained('''facebook/rag-sequence-nq'''		)
        _snake_case		:	str					     =     [
            '''who got the first nobel prize in physics''',
            '''when is the next deadpool movie being released''',
            '''which mode is used for short wave broadcast service''',
            '''who is the owner of reading football club''',
            '''when is the next scandal episode coming out''',
            '''when is the last time the philadelphia won the superbowl''',
            '''what is the most current adobe flash player version''',
            '''how many episodes are there in dragon ball z''',
            '''what is the first step in the evolution of the eye''',
            '''where is gall bladder situated in human body''',
            '''what is the main mineral in lithium batteries''',
            '''who is the president of usa right now''',
            '''where do the greasers live in the outsiders''',
            '''panda is a national animal of which country''',
            '''what is the name of manchester united stadium''',
        ]
        _snake_case		:	Any					     =     tokenizer(lowercase__		)
        self.assertIsNotNone(lowercase__		)









'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import LEDConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers import TFLEDForConditionalGeneration, TFLEDModel





@require_tf
class lowerCamelCase						:
  _lowercase  :	Any       					=				LEDConfig
  _lowercase  :	Any       					=				{}
  _lowercase  :	Optional[Any]       					=				"""gelu"""







  def __init__(		self     ,     lowercase__     ,     lowercase__=13     ,     lowercase__=7     ,     lowercase__=True     ,     lowercase__=False     ,     lowercase__=99     ,     lowercase__=32     ,     lowercase__=2     ,     lowercase__=4     ,     lowercase__=37     ,     lowercase__=0.1     ,     lowercase__=0.1     ,     lowercase__=20     ,     lowercase__=2     ,     lowercase__=1     ,     lowercase__=0     ,     lowercase__=4     ,     )		->						Any:






        """simple docstring"""





        _snake_case		:	Dict					     =     parent
        _snake_case		:	Any					     =     batch_size
        _snake_case		:	List[str]					     =     seq_length
        _snake_case		:	Union[str, Any]					     =     is_training
        _snake_case		:	Tuple					     =     use_labels
        _snake_case		:	int					     =     vocab_size
        _snake_case		:	str					     =     hidden_size
        _snake_case		:	Optional[Any]					     =     num_hidden_layers
        _snake_case		:	List[Any]					     =     num_attention_heads
        _snake_case		:	Optional[int]					     =     intermediate_size

        _snake_case		:	List[Any]					     =     hidden_dropout_prob
        _snake_case		:	List[str]					     =     attention_probs_dropout_prob
        _snake_case		:	Optional[int]					     =     max_position_embeddings
        _snake_case		:	Any					     =     eos_token_id
        _snake_case		:	List[Any]					     =     pad_token_id
        _snake_case		:	Optional[int]					     =     bos_token_id
        _snake_case		:	Any					     =     attention_window

        # `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size
        # [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention
        # returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1]
        # because its local attention only attends to `self.attention_window` and one before and one after
        _snake_case		:	Any					     =     self.attention_window + 2

        # because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for
        # the `test_attention_outputs` and `test_hidden_states_output` tests
        _snake_case		:	Tuple					     =     (
            self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
        )







  def 				UpperCAmelCase_				(		self		)		->						Optional[int]:






        """simple docstring"""





        _snake_case		:	Optional[int]					     =     ids_tensor([self.batch_size, self.seq_length - 1]     ,     self.vocab_size		)
        _snake_case		:	Tuple					     =     tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size		)     ,     1		)
        _snake_case		:	Optional[int]					     =     tf.concat([input_ids, eos_tensor]     ,     axis=1		)

        _snake_case		:	Union[str, Any]					     =     ids_tensor([self.batch_size, self.seq_length]     ,     self.vocab_size		)

        _snake_case		:	List[Any]					     =     self.config_cls(
            vocab_size=self.vocab_size     ,     d_model=self.hidden_size     ,     encoder_layers=self.num_hidden_layers     ,     decoder_layers=self.num_hidden_layers     ,     encoder_attention_heads=self.num_attention_heads     ,     decoder_attention_heads=self.num_attention_heads     ,     encoder_ffn_dim=self.intermediate_size     ,     decoder_ffn_dim=self.intermediate_size     ,     dropout=self.hidden_dropout_prob     ,     attention_dropout=self.attention_probs_dropout_prob     ,     max_position_embeddings=self.max_position_embeddings     ,     eos_token_ids=[2]     ,     bos_token_id=self.bos_token_id     ,     pad_token_id=self.pad_token_id     ,     decoder_start_token_id=self.pad_token_id     ,     attention_window=self.attention_window     ,     **self.config_updates     ,     )
        _snake_case		:	Dict					     =     prepare_led_inputs_dict(lowercase__     ,     lowercase__     ,     lowercase__		)
        _snake_case		:	Dict					     =     tf.concat(
            [tf.zeros_like(lowercase__		)[:, :-1], tf.ones_like(lowercase__		)[:, -1:]]     ,     axis=-1     ,     )
        _snake_case		:	Dict					     =     global_attention_mask
        return config, inputs_dict







  def 				UpperCAmelCase_				(		self     ,     lowercase__     ,     lowercase__		)		->						int:






        """simple docstring"""





        _snake_case		:	int					     =     TFLEDModel(config=lowercase__		).get_decoder()
        _snake_case		:	Union[str, Any]					     =     inputs_dict['''input_ids''']

        _snake_case		:	List[str]					     =     input_ids[:1, :]
        _snake_case		:	Tuple					     =     inputs_dict['''attention_mask'''][:1, :]
        _snake_case		:	Dict					     =     1

        # first forward pass
        _snake_case		:	Optional[int]					     =     model(lowercase__     ,     attention_mask=lowercase__     ,     use_cache=lowercase__		)

        _snake_case     ,							_snake_case		:	Dict					     =     outputs.to_tuple()

        # create hypothetical next token and extent to next_input_ids
        _snake_case		:	Optional[int]					     =     ids_tensor((self.batch_size, 3)     ,     config.vocab_size		)
        _snake_case		:	Any					     =     tf.cast(ids_tensor((self.batch_size, 3)     ,     2		)     ,     tf.inta		)

        # append to next input_ids and
        _snake_case		:	Tuple					     =     tf.concat([input_ids, next_tokens]     ,     axis=-1		)
        _snake_case		:	List[Any]					     =     tf.concat([attention_mask, next_attn_mask]     ,     axis=-1		)

        _snake_case		:	List[Any]					     =     model(lowercase__     ,     attention_mask=lowercase__		)[0]
        _snake_case		:	Tuple					     =     model(lowercase__     ,     attention_mask=lowercase__     ,     past_key_values=lowercase__		)[0]

        self.parent.assertEqual(next_tokens.shape[1]     ,     output_from_past.shape[1]		)

        # select random slice
        _snake_case		:	Tuple					     =     int(ids_tensor((1,)     ,     output_from_past.shape[-1]		)		)
        _snake_case		:	int					     =     output_from_no_past[:, -3:, random_slice_idx]
        _snake_case		:	Optional[Any]					     =     output_from_past[:, :, random_slice_idx]

        # test that outputs are equal for slice
        tf.debugging.assert_near(lowercase__     ,     lowercase__     ,     rtol=1E-3		)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_=None			,      lowerCAmelCase_=None			,      lowerCAmelCase_=None			,      lowerCAmelCase_=None			,      ):





      """simple docstring"""



      if attention_mask is None:
            _snake_case		:	Union[str, Any]					     =     tf.cast(tf.math.not_equal(lowerCAmelCase_			,      config.pad_token_id	)			,      tf.inta	)
      if decoder_attention_mask is None:
            _snake_case		:	str					     =     tf.concat(
                [
                    tf.ones(decoder_input_ids[:, :1].shape			,      dtype=tf.inta	),
                    tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]			,      config.pad_token_id	)			,      tf.inta	),
                ]			,      axis=-1			,      )
      if head_mask is None:
            _snake_case		:	int					     =     tf.ones((config.encoder_layers, config.encoder_attention_heads)	)
      if decoder_head_mask is None:
            _snake_case		:	List[str]					     =     tf.ones((config.decoder_layers, config.decoder_attention_heads)	)
      return {
          "input_ids": input_ids,
          "attention_mask": attention_mask,
          "decoder_input_ids": decoder_input_ids,
          "decoder_attention_mask": decoder_attention_mask,
          "head_mask": head_mask,
          "decoder_head_mask": decoder_head_mask,
      }





@require_tf
class lowerCamelCase						(a__						,      a__						,      unittest.TestCase					):
  _lowercase  :	Optional[int]       					=				(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
  _lowercase  :	int       					=				(TFLEDForConditionalGeneration,) if is_tf_available() else ()
  _lowercase  :	Dict       					=				(
      {
          """conversational""": TFLEDForConditionalGeneration,
          """feature-extraction""": TFLEDModel,
          """summarization""": TFLEDForConditionalGeneration,
          """text2text-generation""": TFLEDForConditionalGeneration,
          """translation""": TFLEDForConditionalGeneration,
      }
      if is_tf_available()
      else {}
  )
  _lowercase  :	int       					=				True
  _lowercase  :	List[Any]       					=				False
  _lowercase  :	str       					=				False
  _lowercase  :	Union[str, Any]       					=				False







  def 				UpperCAmelCase_				(		self		)		->						Optional[Any]:






        """simple docstring"""





        _snake_case		:	str					     =     TFLEDModelTester(self		)
        _snake_case		:	Union[str, Any]					     =     ConfigTester(self     ,     config_class=lowercase__		)







  def 				UpperCAmelCase_				(		self		)		->						Tuple:






        """simple docstring"""





        self.config_tester.run_common_tests()







  def 				UpperCAmelCase_				(		self		)		->						List[str]:






        """simple docstring"""





        _snake_case		:	List[Any]					     =     self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.check_decoder_model_past_large_inputs(*lowercase__		)







  def 				UpperCAmelCase_				(		self		)		->						int:






        """simple docstring"""





        _snake_case     ,							_snake_case		:	List[Any]					     =     self.model_tester.prepare_config_and_inputs_for_common()
        _snake_case		:	Any					     =     tf.zeros_like(inputs_dict['''attention_mask''']		)
        _snake_case		:	Optional[Any]					     =     2
        _snake_case		:	Any					     =     tf.where(
            tf.range(self.model_tester.seq_length		)[None, :] < num_global_attn_indices     ,     1     ,     inputs_dict['''global_attention_mask''']     ,     )

        _snake_case		:	Dict					     =     True
        _snake_case		:	str					     =     self.model_tester.seq_length
        _snake_case		:	Dict					     =     self.model_tester.encoder_seq_length

        def check_decoder_attentions_output(lowercase__		):
              _snake_case		:	Optional[int]					     =     outputs.decoder_attentions
              self.assertEqual(len(lowercase__		)     ,     self.model_tester.num_hidden_layers		)
              self.assertListEqual(
                  list(decoder_attentions[0].shape[-3:]		)     ,     [self.model_tester.num_attention_heads, seq_length, seq_length]     ,     )

        def check_encoder_attentions_output(lowercase__		):
              _snake_case		:	int					     =     [t.numpy() for t in outputs.encoder_attentions]
              _snake_case		:	Tuple					     =     [t.numpy() for t in outputs.encoder_global_attentions]
              self.assertEqual(len(lowercase__		)     ,     self.model_tester.num_hidden_layers		)
              self.assertEqual(len(lowercase__		)     ,     self.model_tester.num_hidden_layers		)
              self.assertListEqual(
                  list(attentions[0].shape[-3:]		)     ,     [self.model_tester.num_attention_heads, seq_length, seq_length]     ,     )
              self.assertListEqual(
                  list(global_attentions[0].shape[-3:]		)     ,     [self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices]     ,     )

        for model_class in self.all_model_classes:
              _snake_case		:	Union[str, Any]					     =     True
              _snake_case		:	Dict					     =     False
              _snake_case		:	Union[str, Any]					     =     False
              _snake_case		:	List[Any]					     =     model_class(lowercase__		)
              _snake_case		:	Optional[Any]					     =     model(self._prepare_for_class(lowercase__     ,     lowercase__		)		)
              _snake_case		:	List[Any]					     =     len(lowercase__		)
              self.assertEqual(config.output_hidden_states     ,     lowercase__		)
              check_encoder_attentions_output(lowercase__		)

              if self.is_encoder_decoder:
                    _snake_case		:	Union[str, Any]					     =     model_class(lowercase__		)
                    _snake_case		:	List[Any]					     =     model(self._prepare_for_class(lowercase__     ,     lowercase__		)		)
                    self.assertEqual(config.output_hidden_states     ,     lowercase__		)
                    check_decoder_attentions_output(lowercase__		)

              # Check that output attentions can also be changed via the config
              del inputs_dict["output_attentions"]
              _snake_case		:	str					     =     True
              _snake_case		:	Tuple					     =     model_class(lowercase__		)
              _snake_case		:	int					     =     model(self._prepare_for_class(lowercase__     ,     lowercase__		)		)
              self.assertEqual(config.output_hidden_states     ,     lowercase__		)
              check_encoder_attentions_output(lowercase__		)

              # Check attention is always last and order is fine
              _snake_case		:	int					     =     True
              _snake_case		:	List[str]					     =     True
              _snake_case		:	Tuple					     =     model_class(lowercase__		)
              _snake_case		:	Optional[Any]					     =     model(self._prepare_for_class(lowercase__     ,     lowercase__		)		)

              self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)     ,     len(lowercase__		)		)
              self.assertEqual(model.config.output_hidden_states     ,     lowercase__		)
              check_encoder_attentions_output(lowercase__		)







  @unittest.skip('''LED keeps using potentially symbolic tensors in conditionals and breaks tracing.'''		)
  def 				UpperCAmelCase_				(		self		)		->						int:






        """simple docstring"""





        pass







  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        pass




def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      return tf.constant(lowerCAmelCase_			,      dtype=tf.intaa	)


UpperCAmelCase					:		Dict		=							1E-4





@slow
@require_tf
class lowerCamelCase						(unittest.TestCase					):







  def 				UpperCAmelCase_				(		self		)		->						Dict:






        """simple docstring"""





        _snake_case		:	List[str]					     =     TFLEDForConditionalGeneration.from_pretrained('''allenai/led-base-16384'''		).led

        # change to intended input here
        _snake_case		:	List[str]					     =     _long_tensor([512 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]		)
        _snake_case		:	Tuple					     =     _long_tensor([128 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]		)
        _snake_case		:	Tuple					     =     prepare_led_inputs_dict(model.config     ,     lowercase__     ,     lowercase__		)
        _snake_case		:	int					     =     model(**lowercase__		)[0]
        _snake_case		:	Dict					     =     (1, 1_024, 768)
        self.assertEqual(output.shape     ,     lowercase__		)
        # change to expected output here
        _snake_case		:	List[Any]					     =     tf.convert_to_tensor(
            [[2.3_050, 2.8_279, 0.6_531], [-1.8_457, -0.1_455, -3.5_661], [-1.0_186, 0.4_586, -2.2_043]]     ,     )
        tf.debugging.assert_near(output[:, :3, :3]     ,     lowercase__     ,     atol=1E-3		)







  def 				UpperCAmelCase_				(		self		)		->						List[Any]:






        """simple docstring"""





        _snake_case		:	Any					     =     TFLEDForConditionalGeneration.from_pretrained('''allenai/led-base-16384'''		)

        # change to intended input here
        _snake_case		:	Dict					     =     _long_tensor([512 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]		)
        _snake_case		:	Dict					     =     _long_tensor([128 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]		)
        _snake_case		:	List[str]					     =     prepare_led_inputs_dict(model.config     ,     lowercase__     ,     lowercase__		)
        _snake_case		:	Tuple					     =     model(**lowercase__		)[0]
        _snake_case		:	Any					     =     (1, 1_024, model.config.vocab_size)
        self.assertEqual(output.shape     ,     lowercase__		)
        # change to expected output here
        _snake_case		:	Dict					     =     tf.convert_to_tensor(
            [[33.6_507, 6.4_572, 16.8_089], [5.8_739, -2.4_238, 11.2_902], [-3.2_139, -4.3_149, 4.2_783]]     ,     )
        tf.debugging.assert_near(output[:, :3, :3]     ,     lowercase__     ,     atol=1E-3     ,     rtol=1E-3		)


