






import tempfile
import unittest

import numpy as np

import transformers
from transformers import GPTaTokenizer, GPTJConfig, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, tooslow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
 import jax
 import jax.numpy as jnp

 from transformers.modeling_flax_pytorch_utils import (
     convert_pytorch_state_dict_to_flax,
     load_flax_weights_in_pytorch_model,
 )
 from transformers.models.gptj.modeling_flax_gptj import FlaxGPTJForCausalLM, FlaxGPTJModel

if is_torch_available():
 import torch


class     _a							:






  """simple docstring"""





  def __init__(  self		,		_UpperCAmelCase		,		_UpperCAmelCase=14		,		_UpperCAmelCase=7		,		_UpperCAmelCase=True		,		_UpperCAmelCase=True		,		_UpperCAmelCase=False		,		_UpperCAmelCase=True		,		_UpperCAmelCase=99		,		_UpperCAmelCase=32		,		_UpperCAmelCase=4		,		_UpperCAmelCase=4		,		_UpperCAmelCase=4		,		_UpperCAmelCase=37		,		_UpperCAmelCase="gelu"		,		_UpperCAmelCase=0.1		,		_UpperCAmelCase=0.1		,		_UpperCAmelCase=512		,		_UpperCAmelCase=0.0_2		,		)      ->			Dict:
     UpperCamelCase_						=  parent
     UpperCamelCase_						=  batch_size
     UpperCamelCase_						=  seq_length
     UpperCamelCase_						=  is_training
     UpperCamelCase_						=  use_input_mask
     UpperCamelCase_						=  use_token_type_ids
     UpperCamelCase_						=  use_labels
     UpperCamelCase_						=  vocab_size
     UpperCamelCase_						=  hidden_size
     UpperCamelCase_						=  rotary_dim
     UpperCamelCase_						=  num_hidden_layers
     UpperCamelCase_						=  num_attention_heads
     UpperCamelCase_						=  intermediate_size
     UpperCamelCase_						=  hidden_act
     UpperCamelCase_						=  hidden_dropout_prob
     UpperCamelCase_						=  attention_probs_dropout_prob
     UpperCamelCase_						=  max_position_embeddings
     UpperCamelCase_						=  initializer_range
     UpperCamelCase_						=  None
     UpperCamelCase_						=  vocab_size - 1
     UpperCamelCase_						=  vocab_size - 1
     UpperCamelCase_						=  vocab_size - 1




  def  _UpperCAmelCase  (  self			)      ->			Tuple:
     UpperCamelCase_						=  ids_tensor([self.batch_size, self.seq_length]		,		self.vocab_size			)

     UpperCamelCase_						=  None
     if self.use_input_mask:
        UpperCamelCase_						=  random_attention_mask([self.batch_size, self.seq_length]			)

     UpperCamelCase_						=  GPTJConfig(
         vocab_size=self.vocab_size		,		n_embd=self.hidden_size		,		n_layer=self.num_hidden_layers		,		n_head=self.num_attention_heads		,		n_positions=self.max_position_embeddings		,		use_cache=_UpperCAmelCase		,		bos_token_id=self.bos_token_id		,		eos_token_id=self.eos_token_id		,		pad_token_id=self.pad_token_id		,		rotary_dim=self.rotary_dim		,		)

     return (config, input_ids, input_mask)




  def  _UpperCAmelCase  (  self			)      ->			Optional[Any]:
     UpperCamelCase_						=  self.prepare_config_and_inputs()
     UpperCamelCase_		,   UpperCamelCase_		,   UpperCamelCase_						=  config_and_inputs
     UpperCamelCase_						=  {'input_ids': input_ids, 'attention_mask': attention_mask}
     return config, inputs_dict




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Tuple:
     UpperCamelCase_						=  20
     UpperCamelCase_						=  model_class_name(_UpperCAmelCase			)

     UpperCamelCase_						=  model.init_cache(input_ids.shape[0]		,		_UpperCAmelCase			)
     UpperCamelCase_						=  jnp.ones((input_ids.shape[0], max_decoder_length)		,		dtype='i4'			)

     UpperCamelCase_						=  jnp.broadcast_to(
         jnp.arange(input_ids.shape[-1] - 1			)[None, :]		,		(input_ids.shape[0], input_ids.shape[-1] - 1)			)
     UpperCamelCase_						=  model(
         input_ids[:, :-1]		,		attention_mask=_UpperCAmelCase		,		past_key_values=_UpperCAmelCase		,		position_ids=_UpperCAmelCase		,		)

     UpperCamelCase_						=  jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]		,		dtype='i4'			)
     UpperCamelCase_						=  model(
         input_ids[:, -1:]		,		attention_mask=_UpperCAmelCase		,		past_key_values=outputs_cache.past_key_values		,		position_ids=_UpperCAmelCase		,		)

     UpperCamelCase_						=  model(_UpperCAmelCase			)

     UpperCamelCase_						=  np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])			)			)
     self.parent.assertTrue(diff < 1e-3		,		msg=f"""Max diff is {diff}"""			)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Optional[int]:
     UpperCamelCase_						=  20
     UpperCamelCase_						=  model_class_name(_UpperCAmelCase			)

     UpperCamelCase_						=  jnp.concatenate(
         [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])			)]		,		axis=-1		,		)

     UpperCamelCase_						=  model.init_cache(input_ids.shape[0]		,		_UpperCAmelCase			)
     UpperCamelCase_						=  jnp.broadcast_to(
         jnp.arange(input_ids.shape[-1] - 1			)[None, :]		,		(input_ids.shape[0], input_ids.shape[-1] - 1)			)

     UpperCamelCase_						=  model(
         input_ids[:, :-1]		,		attention_mask=_UpperCAmelCase		,		past_key_values=_UpperCAmelCase		,		position_ids=_UpperCAmelCase		,		)
     UpperCamelCase_						=  jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]		,		dtype='i4'			)
     UpperCamelCase_						=  model(
         input_ids[:, -1:]		,		past_key_values=outputs_cache.past_key_values		,		attention_mask=_UpperCAmelCase		,		position_ids=_UpperCAmelCase		,		)

     UpperCamelCase_						=  model(_UpperCAmelCase		,		attention_mask=_UpperCAmelCase			)

     UpperCamelCase_						=  np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])			)			)
     self.parent.assertTrue(diff < 1e-3		,		msg=f"""Max diff is {diff}"""			)




@require_flax
class     _a							(	UpperCAmelCase__    ,							UpperCAmelCase__    ,							unittest.TestCase     ):






  """simple docstring"""





  A_						       = (FlaxGPTJModel, FlaxGPTJForCausalLM) if is_flax_available() else ()
  A_						       = (FlaxGPTJForCausalLM,) if is_flax_available() else ()




  def  _UpperCAmelCase  (  self			)      ->			str:
     UpperCamelCase_						=  FlaxGPTJModelTester(self			)




  def  _UpperCAmelCase  (  self			)      ->			Any:
     for model_class_name in self.all_model_classes:
        UpperCamelCase_		,   UpperCamelCase_		,   UpperCamelCase_						=  self.model_tester.prepare_config_and_inputs()
        self.model_tester.check_use_cache_forward(_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase			)




  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     for model_class_name in self.all_model_classes:
        UpperCamelCase_		,   UpperCamelCase_		,   UpperCamelCase_						=  self.model_tester.prepare_config_and_inputs()
        self.model_tester.check_use_cache_forward_with_attn_mask(
            _UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase			)




  @tooslow
  def  _UpperCAmelCase  (  self			)      ->			Optional[Any]:
     UpperCamelCase_						=  GPTaTokenizer.from_pretrained('gpt2'		,		pad_token='<|endoftext|>'		,		padding_side='left'			)
     UpperCamelCase_						=  tokenizer(['Hello this is a long string', 'Hey']		,		return_tensors='np'		,		padding=_UpperCAmelCase		,		truncation=_UpperCAmelCase			)

     UpperCamelCase_						=  FlaxGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'			)
     UpperCamelCase_						=  False
     UpperCamelCase_						=  model.config.eos_token_id

     UpperCamelCase_						=  jax.jit(model.generate			)

     UpperCamelCase_						=  jit_generate(
         inputs['input_ids']		,		attention_mask=inputs['attention_mask']		,		pad_token_id=tokenizer.pad_token_id			).sequences

     UpperCamelCase_						=  tokenizer.batch_decode(_UpperCAmelCase		,		skip_special_tokens=_UpperCAmelCase			)

     UpperCamelCase_						=  [
         'Hello this is a long string of text.\n\nI\'m trying to get the text of the',
         'Hey, I\'m a little late to the party. I\'m going to',
     ]

     self.assertListEqual(_UpperCAmelCase		,		_UpperCAmelCase			)




  @is_pt_flax_cross_test
  def  _UpperCAmelCase  (  self			)      ->			Union[str, Any]:
     UpperCamelCase_		,   UpperCamelCase_						=  self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        with self.subTest(model_class.__name__			):
           # prepare inputs
           UpperCamelCase_						=  self._prepare_for_class(_UpperCAmelCase		,		_UpperCAmelCase			)
           UpperCamelCase_						=  {k: torch.tensor(v.tolist()			) for k, v in prepared_inputs_dict.items()}

           # load corresponding PyTorch class
           UpperCamelCase_						=  model_class.__name__[4:]  # Skip the "Flax" at the beginning
           UpperCamelCase_						=  getattr(_UpperCAmelCase		,		_UpperCAmelCase			)

           UpperCamelCase_		,   UpperCamelCase_						=  pt_inputs['input_ids'].shape
           UpperCamelCase_						=  np.random.randint(0		,		seq_length - 1		,		size=(batch_size,)			)
           for batch_idx, start_index in enumerate(_UpperCAmelCase			):
              UpperCamelCase_						=  0
              UpperCamelCase_						=  1
              UpperCamelCase_						=  0
              UpperCamelCase_						=  1
           UpperCamelCase_						=  pt_model_class(_UpperCAmelCase			).eval()
           UpperCamelCase_						=  model_class(_UpperCAmelCase		,		dtype=jnp.floataa			)

           UpperCamelCase_						=  convert_pytorch_state_dict_to_flax(pt_model.state_dict()		,		_UpperCAmelCase			)
           UpperCamelCase_						=  fx_state

           with torch.no_grad():
              UpperCamelCase_						=  pt_model(**_UpperCAmelCase			).to_tuple()

           UpperCamelCase_						=  fx_model(**_UpperCAmelCase			).to_tuple()
           self.assertEqual(len(_UpperCAmelCase			)		,		len(_UpperCAmelCase			)		,		'Output lengths differ between Flax and PyTorch'			)
           for fx_output, pt_output in zip(_UpperCAmelCase		,		_UpperCAmelCase			):
              self.assert_almost_equals(fx_output[:, -1]		,		pt_output[:, -1].numpy()		,		4e-2			)

           with tempfile.TemporaryDirectory() as tmpdirname:
              pt_model.save_pretrained(_UpperCAmelCase			)
              UpperCamelCase_						=  model_class.from_pretrained(_UpperCAmelCase		,		from_pt=_UpperCAmelCase			)

           UpperCamelCase_						=  fx_model_loaded(**_UpperCAmelCase			).to_tuple()
           self.assertEqual(
               len(_UpperCAmelCase			)		,		len(_UpperCAmelCase			)		,		'Output lengths differ between Flax and PyTorch'			)
           for fx_output_loaded, pt_output in zip(_UpperCAmelCase		,		_UpperCAmelCase			):
              self.assert_almost_equals(fx_output_loaded[:, -1]		,		pt_output[:, -1].numpy()		,		4e-2			)




  @is_pt_flax_cross_test
  def  _UpperCAmelCase  (  self			)      ->			Tuple:
     UpperCamelCase_		,   UpperCamelCase_						=  self.model_tester.prepare_config_and_inputs_for_common()
     for model_class in self.all_model_classes:
        with self.subTest(model_class.__name__			):
           # prepare inputs
           UpperCamelCase_						=  self._prepare_for_class(_UpperCAmelCase		,		_UpperCAmelCase			)
           UpperCamelCase_						=  {k: torch.tensor(v.tolist()			) for k, v in prepared_inputs_dict.items()}

           # load corresponding PyTorch class
           UpperCamelCase_						=  model_class.__name__[4:]  # Skip the "Flax" at the beginning
           UpperCamelCase_						=  getattr(_UpperCAmelCase		,		_UpperCAmelCase			)

           UpperCamelCase_						=  pt_model_class(_UpperCAmelCase			).eval()
           UpperCamelCase_						=  model_class(_UpperCAmelCase		,		dtype=jnp.floataa			)

           UpperCamelCase_						=  load_flax_weights_in_pytorch_model(_UpperCAmelCase		,		fx_model.params			)
           UpperCamelCase_		,   UpperCamelCase_						=  pt_inputs['input_ids'].shape
           UpperCamelCase_						=  np.random.randint(0		,		seq_length - 1		,		size=(batch_size,)			)
           for batch_idx, start_index in enumerate(_UpperCAmelCase			):
              UpperCamelCase_						=  0
              UpperCamelCase_						=  1
              UpperCamelCase_						=  0
              UpperCamelCase_						=  1

           # make sure weights are tied in PyTorch
           pt_model.tie_weights()

           with torch.no_grad():
              UpperCamelCase_						=  pt_model(**_UpperCAmelCase			).to_tuple()

           UpperCamelCase_						=  fx_model(**_UpperCAmelCase			).to_tuple()
           self.assertEqual(len(_UpperCAmelCase			)		,		len(_UpperCAmelCase			)		,		'Output lengths differ between Flax and PyTorch'			)
           for fx_output, pt_output in zip(_UpperCAmelCase		,		_UpperCAmelCase			):
              self.assert_almost_equals(fx_output[:, -1]		,		pt_output[:, -1].numpy()		,		4e-2			)

           with tempfile.TemporaryDirectory() as tmpdirname:
              fx_model.save_pretrained(_UpperCAmelCase			)
              UpperCamelCase_						=  pt_model_class.from_pretrained(_UpperCAmelCase		,		from_flax=_UpperCAmelCase			)

           with torch.no_grad():
              UpperCamelCase_						=  pt_model_loaded(**_UpperCAmelCase			).to_tuple()

           self.assertEqual(
               len(_UpperCAmelCase			)		,		len(_UpperCAmelCase			)		,		'Output lengths differ between Flax and PyTorch'			)
           for fx_output, pt_output in zip(_UpperCAmelCase		,		_UpperCAmelCase			):
              self.assert_almost_equals(fx_output[:, -1]		,		pt_output[:, -1].numpy()		,		4e-2			)




  @tooslow
  def  _UpperCAmelCase  (  self			)      ->			Optional[int]:
     for model_class_name in self.all_model_classes:
        UpperCamelCase_						=  model_class_name.from_pretrained('EleutherAI/gpt-j-6B'			)
        UpperCamelCase_						=  model(np.ones((1, 1)			)			)
        self.assertIsNotNone(_UpperCAmelCase			)













import unittest

import numpy as np

from transformers import RobertaPreLayerNormConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
							import jax.numpy as jnp

							from transformers.models.roberta_prelayernorm.modeling_flax_roberta_prelayernorm import (
							    FlaxRobertaPreLayerNormForCausalLM,
							    FlaxRobertaPreLayerNormForMaskedLM,
							    FlaxRobertaPreLayerNormForMultipleChoice,
							    FlaxRobertaPreLayerNormForQuestionAnswering,
							    FlaxRobertaPreLayerNormForSequenceClassification,
							    FlaxRobertaPreLayerNormForTokenClassification,
							    FlaxRobertaPreLayerNormModel,
							)
class  _UpperCAmelCase   (			unittest.TestCase      ):

				"""simple docstring"""




				def __init__(	self		:       List[Any],    lowerCamelCase		:       Dict,    lowerCamelCase		:       Dict=13,    lowerCamelCase		:       Optional[int]=7,    lowerCamelCase		:       Optional[Any]=True,    lowerCamelCase		:       Union[str, Any]=True,    lowerCamelCase		:       Optional[Any]=True,    lowerCamelCase		:       Optional[Any]=True,    lowerCamelCase		:       List[Any]=99,    lowerCamelCase		:       Any=32,    lowerCamelCase		:       List[str]=5,    lowerCamelCase		:       Union[str, Any]=4,    lowerCamelCase		:       Union[str, Any]=37,    lowerCamelCase		:       Optional[int]="gelu",    lowerCamelCase		:       Tuple=0.1,    lowerCamelCase		:       List[str]=0.1,    lowerCamelCase		:       Optional[Any]=512,    lowerCamelCase		:       int=16,    lowerCamelCase		:       str=2,    lowerCamelCase		:       int=0.02,    lowerCamelCase		:       int=4,    ):

								'''simple docstring'''
								lowercase__  					=     parent
								lowercase__  					=     batch_size
								lowercase__  					=     seq_length
								lowercase__  					=     is_training
								lowercase__  					=     use_attention_mask
								lowercase__  					=     use_token_type_ids
								lowercase__  					=     use_labels
								lowercase__  					=     vocab_size
								lowercase__  					=     hidden_size
								lowercase__  					=     num_hidden_layers
								lowercase__  					=     num_attention_heads
								lowercase__  					=     intermediate_size
								lowercase__  					=     hidden_act
								lowercase__  					=     hidden_dropout_prob
								lowercase__  					=     attention_probs_dropout_prob
								lowercase__  					=     max_position_embeddings
								lowercase__  					=     type_vocab_size
								lowercase__  					=     type_sequence_label_size
								lowercase__  					=     initializer_range
								lowercase__  					=     num_choices




				def 							lowercase__  (	self		:       Dict    ):

								'''simple docstring'''
								lowercase__  					=     ids_tensor([self.batch_size, self.seq_length],    self.vocab_size    )

								lowercase__  					=     None
								if self.use_attention_mask:
												lowercase__  					=     random_attention_mask([self.batch_size, self.seq_length]    )

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

								lowercase__  					=     RobertaPreLayerNormConfig(
								    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,    is_decoder=lowerCamelCase,    initializer_range=self.initializer_range,    )

								return config, input_ids, token_type_ids, attention_mask




				def 							lowercase__  (	self		:       List[str]    ):

								'''simple docstring'''
								lowercase__  					=     self.prepare_config_and_inputs()
								lowercase__					,		lowercase__					,		lowercase__					,		lowercase__  					=     config_and_inputs
								lowercase__  					=     {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
								return config, inputs_dict




				def 							lowercase__  (	self		:       Optional[int]    ):

								'''simple docstring'''
								lowercase__  					=     self.prepare_config_and_inputs()
								lowercase__					,		lowercase__					,		lowercase__					,		lowercase__  					=     config_and_inputs

								lowercase__  					=     True
								lowercase__  					=     floats_tensor([self.batch_size, self.seq_length, self.hidden_size]    )
								lowercase__  					=     ids_tensor([self.batch_size, self.seq_length],    vocab_size=2    )

								return (
								    config,
								    input_ids,
								    token_type_ids,
								    encoder_hidden_states,
								    encoder_attention_mask,
								)



@require_flax
# Copied from tests.models.roberta.test_modelling_flax_roberta.FlaxRobertaPreLayerNormModelTest with ROBERTA->ROBERTA_PRELAYERNORM,Roberta->RobertaPreLayerNorm,roberta-base->andreasmadsen/efficient_mlm_m0.40
class  _UpperCAmelCase   (			A__						,unittest.TestCase      ):

				"""simple docstring"""




				lowercase__											=			True

				lowercase__											=			(
				    (
				        FlaxRobertaPreLayerNormModel,
				        FlaxRobertaPreLayerNormForCausalLM,
				        FlaxRobertaPreLayerNormForMaskedLM,
				        FlaxRobertaPreLayerNormForSequenceClassification,
				        FlaxRobertaPreLayerNormForTokenClassification,
				        FlaxRobertaPreLayerNormForMultipleChoice,
				        FlaxRobertaPreLayerNormForQuestionAnswering,
				    )
				    if is_flax_available()
				    else ()
				)




				def 							lowercase__  (	self		:       int    ):

								'''simple docstring'''
								lowercase__  					=     FlaxRobertaPreLayerNormModelTester(self    )




				@slow
				def 							lowercase__  (	self		:       List[Any]    ):

								'''simple docstring'''
								for model_class_name in self.all_model_classes:
												lowercase__  					=     model_class_name.from_pretrained('''andreasmadsen/efficient_mlm_m0.40''',    from_pt=lowerCamelCase    )
												lowercase__  					=     model(np.ones((1, 1)    )    )
												self.assertIsNotNone(lowerCamelCase    )



@require_flax
class  _UpperCAmelCase   (			unittest.TestCase      ):

				"""simple docstring"""




				@slow
				def 							lowercase__  (	self		:       Union[str, Any]    ):

								'''simple docstring'''
								lowercase__  					=     FlaxRobertaPreLayerNormForMaskedLM.from_pretrained('''andreasmadsen/efficient_mlm_m0.40''',    from_pt=lowerCamelCase    )

								lowercase__  					=     np.array([[0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]],    dtype=jnp.intaa    )
								lowercase__  					=     model(lowerCamelCase    )[0]
								lowercase__  					=     [1, 11, 50_265]
								self.assertEqual(list(output.shape    ),    lowerCamelCase    )
								# compare the actual values for a slice.
								lowercase__  					=     np.array(
								    [[[40.4880, 18.0199, -5.2367], [-1.8877, -4.0885, 10.7085], [-2.2613, -5.6110, 7.2665]]],    dtype=np.floataa    )
								self.assertTrue(np.allclose(output[:, :3, :3],    lowerCamelCase,    atol=1E-4    )    )




				@slow
				def 							lowercase__  (	self		:       Any    ):

								'''simple docstring'''
								lowercase__  					=     FlaxRobertaPreLayerNormModel.from_pretrained('''andreasmadsen/efficient_mlm_m0.40''',    from_pt=lowerCamelCase    )

								lowercase__  					=     np.array([[0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]],    dtype=jnp.intaa    )
								lowercase__  					=     model(lowerCamelCase    )[0]
								# compare the actual values for a slice.
								lowercase__  					=     np.array(
								    [[[0.0208, -0.0356, 0.0237], [-0.1569, -0.0411, -0.2626], [0.1879, 0.0125, -0.0089]]],    dtype=np.floataa    )
								self.assertTrue(np.allclose(output[:, :3, :3],    lowerCamelCase,    atol=1E-4    )    )




