




'''simple docstring'''

import argparse
import json
import os
from collections import OrderedDict

import numpy as np
import tensorflow as tf
import torch


def 						__magic_name__       (      __UpperCAmelCase      )						->   Dict:

					'''simple docstring'''

					snake_case_		     =							os.path.join(args.tf_model_dir, '''parameters.json'''      )
					snake_case_		     =							json.loads(open(__UpperCAmelCase      ).read()      )
					if not params:
										raise ValueError(
										    F"It seems that the json file at {parameter_file} is empty. Make sure you have a correct json file."      )
					if not args.output.endswith('''.pt'''      ):
										snake_case_		     =							args.output + '''.pt'''
					snake_case_		     =							OrderedDict()
					with tf.device('''/CPU:0'''      ):
										snake_case_		     =							tf.train.load_checkpoint(args.tf_model_dir      )
										snake_case_		     =							reader.get_variable_to_shape_map()
										for key_name in shapes.keys():
															snake_case_		     =							reader.get_tensor(__UpperCAmelCase      ).astype(np.floataa      )
															if key_name.endswith('''/adam_m'''      ) or key_name.endswith('''/adam_v'''      ):
																				continue
															if key_name.startswith('''pasts/'''      ):
																				if key_name.startswith('''pasts/mlp'''      ):
																									snake_case_		     =							int(key_name[9]      )
																				elif key_name.startswith('''pasts/out'''      ):
																									snake_case_		     =							8
																				snake_case_		     =							'''model.sqout.%d.weight''' % (player * 2)  # enter to nn.Sequencial with Tanh, so 2 at a time
																				snake_case_		     =							vnp.transpose([1, 0]      ).copy()  # Mesh-Tensorflow is a diagonal matrix
																				snake_case_		     =							torch.tensor(__UpperCAmelCase      )
															elif key_name.startswith('''model/moe'''      ):
																				snake_case_		     =							int(key_name[9:].split('''/'''      )[0]      )
																				if key_name.endswith('''/switch_gating/kernel'''      ):
																									snake_case_		     =							'''model.blocks.%d.feed_forward.mlp.router.classifier.weight''' % player
																									snake_case_		     =							vnp.transpose([1, 0]      ).copy()  # Mesh-Tensorflow is a diagonal matrix
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
																				elif key_name.endswith('''/softmlp/kernel'''      ):
																									snake_case_		     =							'''model.blocks.%d.feed_forward.soft_bypass_mlp.weight''' % player
																									snake_case_		     =							vnp.transpose([1, 0]      ).copy()  # Mesh-Tensorflow is a diagonal matrix
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
																				elif key_name.endswith('''/wo/kernel'''      ) or key_name.endswith('''/wi/kernel'''      ):
																									snake_case_		     =							key_name[-9:-7]
																									for i in range(16      ):
																														snake_case_		     =							'''model.blocks.%d.feed_forward.mlp.experts.expert_%d.%s.weight''' % (player, i, nlayer)
																														snake_case_		     =							(
																														    vnp[i].transpose([1, 0]      ).copy()
																														)  # In Mesh-Tensorflow, it is one array, so it is divided
																														snake_case_		     =							torch.tensor(__UpperCAmelCase      )
															elif key_name.startswith('''model/mlp'''      ):
																				snake_case_		     =							int(key_name[9:].split('''/'''      )[0]      )
																				if key_name.endswith('''/p1/kernel'''      ):
																									snake_case_		     =							'''model.blocks.%d.feed_forward.mlp.wi.weight''' % player
																									snake_case_		     =							vnp.transpose([1, 0]      ).copy()  # Mesh-Tensorflow is a diagonal matrix
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
																				elif key_name.endswith('''/p1/bias'''      ):
																									snake_case_		     =							'''model.blocks.%d.feed_forward.mlp.wi.bias''' % player
																									snake_case_		     =							vnp.copy()  # same because it is one dimensional
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
																				elif key_name.endswith('''/p2/kernel'''      ):
																									snake_case_		     =							'''model.blocks.%d.feed_forward.mlp.wo.weight''' % player
																									snake_case_		     =							vnp.transpose([1, 0]      ).copy()  # Mesh-Tensorflow is a diagonal matrix
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
																				elif key_name.endswith('''/p2/bias'''      ):
																									snake_case_		     =							'''model.blocks.%d.feed_forward.mlp.wo.bias''' % player
																									snake_case_		     =							vnp.copy()  # same because it is one dimensional
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
															elif key_name.startswith('''model/ln'''      ):
																				snake_case_		     =							int(key_name[8:].split('''/'''      )[0]      )
																				if key_name.endswith('''/b'''      ):
																									snake_case_		     =							'''model.blocks.%d.feed_forward.norm.bias''' % player
																									snake_case_		     =							vnp.copy()  # same because it is one dimensional
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
																				elif key_name.endswith('''/g'''      ):
																									snake_case_		     =							'''model.blocks.%d.feed_forward.norm.weight''' % player
																									snake_case_		     =							vnp.copy()  # same because it is one dimensional
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
															elif key_name.startswith('''model/att'''      ):
																				snake_case_		     =							int(key_name[9:].split('''/'''      )[0]      )
																				if key_name.endswith('''/qkv/kernel'''      ):
																									snake_case_		     =							vnp.copy()  # Compute same dimension as Mesh-tensorflow using einsum
																									snake_case_		     =							state[:, 0, :, :]
																									snake_case_		     =							state[:, 1, :, :]
																									snake_case_		     =							state[:, 2, :, :]
																									snake_case_		     =							(
																									    state_q.reshape([state_q.shape[0], state_q.shape[1] * state_q.shape[2]]      )
																									    .transpose([1, 0]      )
																									    .copy()
																									)  # Mesh-Tensorflow is a diagonal matrix
																									snake_case_		     =							(
																									    state_k.reshape([state_k.shape[0], state_k.shape[1] * state_k.shape[2]]      )
																									    .transpose([1, 0]      )
																									    .copy()
																									)  # Mesh-Tensorflow is a diagonal matrix
																									snake_case_		     =							(
																									    state_v.reshape([state_v.shape[0], state_v.shape[1] * state_v.shape[2]]      )
																									    .transpose([1, 0]      )
																									    .copy()
																									)  # Mesh-Tensorflow is a diagonal matrix
																									snake_case_		     =							'''model.blocks.%d.self_attn.self_attn.q_proj.weight''' % player
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
																									snake_case_		     =							'''model.blocks.%d.self_attn.self_attn.k_proj.weight''' % player
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
																									snake_case_		     =							'''model.blocks.%d.self_attn.self_attn.v_proj.weight''' % player
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
																				elif key_name.endswith('''/o/kernel'''      ):
																									snake_case_		     =							'''model.blocks.%d.self_attn.self_attn.out_proj.weight''' % player
																									snake_case_		     =							(
																									    vnp.reshape([vnp.shape[0] * vnp.shape[1], vnp.shape[2]]      ).transpose([1, 0]      ).copy()
																									)  # Mesh-Tensorflow is a diagonal matrix
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
															elif key_name.startswith('''model/an'''      ):
																				snake_case_		     =							int(key_name[8:].split('''/'''      )[0]      )
																				if key_name.endswith('''/b'''      ):
																									snake_case_		     =							'''model.blocks.%d.self_attn.norm.bias''' % player
																									snake_case_		     =							vnp.copy()  # same because it is one dimensional
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
																				elif key_name.endswith('''/g'''      ):
																									snake_case_		     =							'''model.blocks.%d.self_attn.norm.weight''' % player
																									snake_case_		     =							vnp.copy()  # same because it is one dimensional
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
															elif (
															    key_name.startswith('''model/wte'''      )
															    or key_name.startswith('''model/wpe'''      )
															    or key_name.startswith('''model/ete'''      )
															):
																				snake_case_		     =							{'''wte''': '''embed_tokens''', '''wpe''': '''position_embeddings''', '''ete''': '''extra_position_embeddings'''}[
																				    key_name[-3:]
																				]
																				snake_case_		     =							'''model.%s.weight''' % nlayer
																				snake_case_		     =							vnp.copy()  # same in embedded
																				snake_case_		     =							torch.tensor(__UpperCAmelCase      )
																				if key_name.startswith('''model/wte'''      ):
																									snake_case_		     =							'''lm_head.weight'''
																									snake_case_		     =							vnp.copy()  # same in embedded
																									snake_case_		     =							torch.tensor(__UpperCAmelCase      )
															elif key_name.startswith('''model/wob'''      ):
																				snake_case_		     =							'''final_logits_bias'''
																				snake_case_		     =							vnp.copy()  # same in embedded
																				snake_case_		     =							state.reshape((1, -1)      )
																				snake_case_		     =							torch.tensor(__UpperCAmelCase      )
															elif key_name == "model/dense/kernel":
																				snake_case_		     =							'''model.last_project.weight'''
																				snake_case_		     =							vnp.transpose([1, 0]      ).copy()  # Mesh-Tensorflow is a diagonal matrix
																				snake_case_		     =							torch.tensor(__UpperCAmelCase      )
															elif key_name == "model/dense_1/bias":
																				snake_case_		     =							'''model.last_project.bias'''
																				snake_case_		     =							vnp.copy()  # same because it is one dimensional
																				snake_case_		     =							torch.tensor(__UpperCAmelCase      )
					torch.save(__UpperCAmelCase, args.output      )


if __name__ == "__main__":
							a    :							int										=    argparse.ArgumentParser(
							    description='model converter.', formatter_class=argparse.ArgumentDefaultsHelpFormatter
							)
							parser.add_argument('--tf_model_dir', metavar='PATH', type=str, required=True, help='import model')
							parser.add_argument('--output', metavar='PATH', type=str, required=True, help='output model')
							a    :							Dict										=    parser.parse_args()
							convert_tf_gptsan_to_pt(args)







'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow

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


if is_tf_available():
							import numpy as np
							import tensorflow as tf

							from transformers import (
							    TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
							    FlaubertConfig,
							    TFFlaubertForMultipleChoice,
							    TFFlaubertForQuestionAnsweringSimple,
							    TFFlaubertForSequenceClassification,
							    TFFlaubertForTokenClassification,
							    TFFlaubertModel,
							    TFFlaubertWithLMHeadModel,
							)






class 		a							:


				def __init__(						self       :   Tuple			,							lowercase_       :   Any			,							):
									snake_case_		     =							parent
									snake_case_		     =							13
									snake_case_		     =							7
									snake_case_		     =							True
									snake_case_		     =							True
									snake_case_		     =							True
									snake_case_		     =							True
									snake_case_		     =							True
									snake_case_		     =							False
									snake_case_		     =							False
									snake_case_		     =							False
									snake_case_		     =							2
									snake_case_		     =							99
									snake_case_		     =							0
									snake_case_		     =							32
									snake_case_		     =							2
									snake_case_		     =							4
									snake_case_		     =							0.1
									snake_case_		     =							0.1
									snake_case_		     =							512
									snake_case_		     =							16
									snake_case_		     =							2
									snake_case_		     =							0.02
									snake_case_		     =							3
									snake_case_		     =							4
									snake_case_		     =							'''last'''
									snake_case_		     =							True
									snake_case_		     =							None
									snake_case_		     =							0


				def     A_					(						self       :   Union[str, Any]   ):
									snake_case_		     =							ids_tensor([self.batch_size, self.seq_length]			,							self.vocab_size   )
									snake_case_		     =							random_attention_mask([self.batch_size, self.seq_length]			,							dtype=tf.floataa   )

									snake_case_		     =							None
									if self.use_input_lengths:
														snake_case_		     =							(
														    ids_tensor([self.batch_size]			,							vocab_size=2   ) + self.seq_length - 2
														)  # small variation of seq_length

									snake_case_		     =							None
									if self.use_token_type_ids:
														snake_case_		     =							ids_tensor([self.batch_size, self.seq_length]			,							self.n_langs   )

									snake_case_		     =							None
									snake_case_		     =							None
									snake_case_		     =							None
									if self.use_labels:
														snake_case_		     =							ids_tensor([self.batch_size]			,							self.type_sequence_label_size   )
														snake_case_		     =							ids_tensor([self.batch_size, self.seq_length]			,							self.num_labels   )
														snake_case_		     =							ids_tensor([self.batch_size]			,							2			,							dtype=tf.floataa   )
														snake_case_		     =							ids_tensor([self.batch_size]			,							self.num_choices   )

									snake_case_		     =							FlaubertConfig(
									    vocab_size=self.vocab_size			,							n_special=self.n_special			,							emb_dim=self.hidden_size			,							n_layers=self.num_hidden_layers			,							n_heads=self.num_attention_heads			,							dropout=self.hidden_dropout_prob			,							attention_dropout=self.attention_probs_dropout_prob			,							gelu_activation=self.gelu_activation			,							sinusoidal_embeddings=self.sinusoidal_embeddings			,							asm=self.asm			,							causal=self.causal			,							n_langs=self.n_langs			,							max_position_embeddings=self.max_position_embeddings			,							initializer_range=self.initializer_range			,							summary_type=self.summary_type			,							use_proj=self.use_proj			,							bos_token_id=self.bos_token_id			,							)

									return (
									    config,
									    input_ids,
									    token_type_ids,
									    input_lengths,
									    sequence_labels,
									    token_labels,
									    is_impossible_labels,
									    choice_labels,
									    input_mask,
									)


				def     A_					(						self       :   List[Any]			,							lowercase_       :   Dict			,							lowercase_       :   Optional[int]			,							lowercase_       :   Any			,							lowercase_       :   List[Any]			,							lowercase_       :   Optional[int]			,							lowercase_       :   int			,							lowercase_       :   int			,							lowercase_       :   str			,							lowercase_       :   int			,							):
									snake_case_		     =							TFFlaubertModel(config=lowercase_   )
									snake_case_		     =							{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
									snake_case_		     =							model(lowercase_   )

									snake_case_		     =							[input_ids, input_mask]
									snake_case_		     =							model(lowercase_   )
									self.parent.assertEqual(result.last_hidden_state.shape			,							(self.batch_size, self.seq_length, self.hidden_size)   )


				def     A_					(						self       :   List[str]			,							lowercase_       :   int			,							lowercase_       :   List[str]			,							lowercase_       :   Optional[Any]			,							lowercase_       :   str			,							lowercase_       :   Tuple			,							lowercase_       :   Tuple			,							lowercase_       :   Any			,							lowercase_       :   Dict			,							lowercase_       :   List[Any]			,							):
									snake_case_		     =							TFFlaubertWithLMHeadModel(lowercase_   )

									snake_case_		     =							{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
									snake_case_		     =							model(lowercase_   )

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


				def     A_					(						self       :   str			,							lowercase_       :   Dict			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   Dict			,							lowercase_       :   Any			,							lowercase_       :   str			,							lowercase_       :   List[str]			,							lowercase_       :   List[Any]			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   str			,							):
									snake_case_		     =							TFFlaubertForQuestionAnsweringSimple(lowercase_   )

									snake_case_		     =							{'''input_ids''': input_ids, '''lengths''': input_lengths}

									snake_case_		     =							model(lowercase_   )

									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       :   Optional[Any]			,							lowercase_       :   Any			,							lowercase_       :   int			,							lowercase_       :   List[Any]			,							lowercase_       :   Any			,							lowercase_       :   Optional[Any]			,							lowercase_       :   str			,							lowercase_       :   int			,							lowercase_       :   int			,							lowercase_       :   Dict			,							):
									snake_case_		     =							TFFlaubertForSequenceClassification(lowercase_   )

									snake_case_		     =							{'''input_ids''': input_ids, '''lengths''': input_lengths}

									snake_case_		     =							model(lowercase_   )

									self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.type_sequence_label_size)   )


				def     A_					(						self       :   List[Any]			,							lowercase_       :   Optional[Any]			,							lowercase_       :   Any			,							lowercase_       :   Any			,							lowercase_       :   List[Any]			,							lowercase_       :   List[Any]			,							lowercase_       :   Dict			,							lowercase_       :   int			,							lowercase_       :   Tuple			,							lowercase_       :   Union[str, Any]			,							):
									snake_case_		     =							self.num_labels
									snake_case_		     =							TFFlaubertForTokenClassification(config=lowercase_   )
									snake_case_		     =							{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
									snake_case_		     =							model(lowercase_   )
									self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.seq_length, self.num_labels)   )


				def     A_					(						self       :   Dict			,							lowercase_       :   Tuple			,							lowercase_       :   Optional[int]			,							lowercase_       :   Any			,							lowercase_       :   List[Any]			,							lowercase_       :   int			,							lowercase_       :   Tuple			,							lowercase_       :   List[str]			,							lowercase_       :   List[Any]			,							lowercase_       :   Any			,							):
									snake_case_		     =							self.num_choices
									snake_case_		     =							TFFlaubertForMultipleChoice(config=lowercase_   )
									snake_case_		     =							tf.tile(tf.expand_dims(lowercase_			,							1   )			,							(1, self.num_choices, 1)   )
									snake_case_		     =							tf.tile(tf.expand_dims(lowercase_			,							1   )			,							(1, self.num_choices, 1)   )
									snake_case_		     =							tf.tile(tf.expand_dims(lowercase_			,							1   )			,							(1, self.num_choices, 1)   )
									snake_case_		     =							{
									    '''input_ids''': multiple_choice_inputs_ids,
									    '''attention_mask''': multiple_choice_input_mask,
									    '''token_type_ids''': multiple_choice_token_type_ids,
									}
									snake_case_		     =							model(lowercase_   )
									self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.num_choices)   )


				def     A_					(						self       :   Dict   ):
									snake_case_		     =							self.prepare_config_and_inputs()
									(
									    (
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,(
									    snake_case_
									)     ,
									)		     =							config_and_inputs
									snake_case_		     =							{
									    '''input_ids''': input_ids,
									    '''token_type_ids''': token_type_ids,
									    '''langs''': token_type_ids,
									    '''lengths''': input_lengths,
									}
									return config, inputs_dict







@require_tf
class 		a							(  _lowerCamelCase  ,	_lowerCamelCase  ,	unittest.TestCase	):
				snake_case_           =						(
				    (
				        TFFlaubertModel,
				        TFFlaubertWithLMHeadModel,
				        TFFlaubertForSequenceClassification,
				        TFFlaubertForQuestionAnsweringSimple,
				        TFFlaubertForTokenClassification,
				        TFFlaubertForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				snake_case_           =						(
				    (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
				)  # TODO (PVP): Check other models whether language generation is also applicable
				snake_case_           =						(
				    {
				        "feature-extraction": TFFlaubertModel,
				        "fill-mask": TFFlaubertWithLMHeadModel,
				        "question-answering": TFFlaubertForQuestionAnsweringSimple,
				        "text-classification": TFFlaubertForSequenceClassification,
				        "token-classification": TFFlaubertForTokenClassification,
				        "zero-shot": TFFlaubertForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				snake_case_           =						False
				snake_case_           =						False


				def     A_					(						self       :   str			,							lowercase_       :   Optional[Any]			,							lowercase_       :   Optional[Any]			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   Optional[Any]   ):
									if (
									    pipeline_test_casse_name == "QAPipelineTests"
									    and tokenizer_name is not None
									    and not tokenizer_name.endswith('''Fast'''   )
									):
														# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
														# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
														# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
														return True

									return False


				def     A_					(						self       :   int   ):
									snake_case_		     =							TFFlaubertModelTester(self   )
									snake_case_		     =							ConfigTester(self			,							config_class=lowercase_			,							emb_dim=37   )


				def     A_					(						self       :   List[str]   ):
									self.config_tester.run_common_tests()


				def     A_					(						self       :   Optional[Any]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_model(*lowercase_   )


				def     A_					(						self       :   Union[str, Any]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_lm_head(*lowercase_   )


				def     A_					(						self       :   Tuple   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_qa(*lowercase_   )


				def     A_					(						self       :   Tuple   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_sequence_classif(*lowercase_   )


				def     A_					(						self       :   List[str]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_for_token_classification(*lowercase_   )


				def     A_					(						self       :   Union[str, Any]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_for_multiple_choice(*lowercase_   )


				@slow
				def     A_					(						self       :   Optional[int]   ):
									for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														snake_case_		     =							TFFlaubertModel.from_pretrained(lowercase_   )
														self.assertIsNotNone(lowercase_   )







@require_tf
@require_sentencepiece
@require_tokenizers
class 		a							(  unittest.TestCase	):


				@slow
				def     A_					(						self       :   int   ):
									snake_case_		     =							TFFlaubertModel.from_pretrained('''jplu/tf-flaubert-small-cased'''   )

									snake_case_		     =							tf.convert_to_tensor(
									    [[0, 158, 735, 2592, 1424, 6727, 82, 1]]			,							dtype=tf.intaa			,							)  # "J'aime flaubert !"

									snake_case_		     =							model(lowercase_   )[0]
									snake_case_		     =							tf.TensorShape((1, 8, 512)   )
									self.assertEqual(output.shape			,							lowercase_   )
									# compare the actual values for a slice.
									snake_case_		     =							tf.convert_to_tensor(
									    [
									        [
									            [-1.876_8773, -1.56_6555, 0.2707_2418],
									            [-1.692_0038, -0.587_3505, 1.932_9599],
									            [-2.956_3985, -1.699_3835, 1.797_2052],
									        ]
									    ]			,							dtype=tf.floataa			,							)

									self.assertTrue(np.allclose(output[:, :3, :3].numpy()			,							expected_slice.numpy()			,							atol=1e-4   )   )

