
import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
		import torch

		from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin





class       __A:

					def __init__(	self					:     Tuple   ,					__UpperCamelCase					:     Dict   ,					__UpperCamelCase					:     Optional[int]=None   ,					__UpperCamelCase					:     List[Any]=None   ,					__UpperCamelCase					:     Tuple=None   ,					__UpperCamelCase					:     str="resnet50"   ,					__UpperCamelCase					:     Union[str, Any]=3   ,					__UpperCamelCase					:     Optional[Any]=3_2   ,					__UpperCamelCase					:     Dict=3   ,					__UpperCamelCase					:     Union[str, Any]=True   ,					__UpperCamelCase					:     Union[str, Any]=True   ,					):
												lowerCamelCase_							  =					parent
												lowerCamelCase_							  =					out_indices if out_indices is not None else [4]
												lowerCamelCase_							  =					stage_names
												lowerCamelCase_							  =					out_features
												lowerCamelCase_							  =					backbone
												lowerCamelCase_							  =					batch_size
												lowerCamelCase_							  =					image_size
												lowerCamelCase_							  =					num_channels
												lowerCamelCase_							  =					use_pretrained_backbone
												lowerCamelCase_							  =					is_training

					def    lowercase__      (	self					:     int   ):
												lowerCamelCase_							  =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )
												lowerCamelCase_							  =					self.get_config()

												return config, pixel_values

					def    lowercase__      (	self					:     Any   ):
												return TimmBackboneConfig(
												    image_size=self.image_size   ,					num_channels=self.num_channels   ,					out_features=self.out_features   ,					out_indices=self.out_indices   ,					stage_names=self.stage_names   ,					use_pretrained_backbone=self.use_pretrained_backbone   ,					backbone=self.backbone   ,					)

					def    lowercase__      (	self					:     Tuple   ,					__UpperCamelCase					:     Dict   ,					__UpperCamelCase					:     List[Any]   ):
												lowerCamelCase_							  =					TimmBackbone(config=__UpperCamelCase   )
												model.to(__UpperCamelCase   )
												model.eval()
												with torch.no_grad():
																			lowerCamelCase_							  =					model(__UpperCamelCase   )
												self.parent.assertEqual(
												    result.feature_map[-1].shape   ,					(self.batch_size, model.channels[-1], 1_4, 1_4)   ,					)



					def    lowercase__      (	self					:     str   ):
												lowerCamelCase_							  =					self.prepare_config_and_inputs()
												lowerCamelCase_  ,   lowerCamelCase_							  =					config_and_inputs
												lowerCamelCase_							  =					{"""pixel_values""": pixel_values}
												return config, inputs_dict





@require_torch
@require_timm
class       __A(				UpperCAmelCase     ,		UpperCAmelCase     ,		UpperCAmelCase     ,		unittest.TestCase       ):
					SCREAMING_SNAKE_CASE			    =    (TimmBackbone,) if is_torch_available() else ()
					SCREAMING_SNAKE_CASE			    =    {'''feature-extraction''': TimmBackbone} if is_torch_available() else {}
					SCREAMING_SNAKE_CASE			    =    False
					SCREAMING_SNAKE_CASE			    =    False
					SCREAMING_SNAKE_CASE			    =    False
					SCREAMING_SNAKE_CASE			    =    False

					def    lowercase__      (	self					:     str   ):
												lowerCamelCase_							  =					TimmBackboneModelTester(self   )
												lowerCamelCase_							  =					ConfigTester(self   ,					config_class=__UpperCamelCase   ,					has_text_modality=__UpperCamelCase   )

					def    lowercase__      (	self					:     Union[str, Any]   ):
												self.config_tester.create_and_test_config_to_json_string()
												self.config_tester.create_and_test_config_to_json_file()
												self.config_tester.create_and_test_config_from_and_save_pretrained()
												self.config_tester.create_and_test_config_with_num_labels()
												self.config_tester.check_config_can_be_init_without_params()
												self.config_tester.check_config_arguments_init()

					def    lowercase__      (	self					:     Any   ):
												lowerCamelCase_							  =					"""resnet18"""
												lowerCamelCase_							  =					"""microsoft/resnet-18"""

												lowerCamelCase_							  =					AutoBackbone.from_pretrained(__UpperCamelCase   ,					use_timm_backbone=__UpperCamelCase   )
												lowerCamelCase_							  =					AutoBackbone.from_pretrained(__UpperCamelCase   )

												self.assertEqual(len(timm_model.out_features   )   ,					len(transformers_model.out_features   )   )
												self.assertEqual(len(timm_model.stage_names   )   ,					len(transformers_model.stage_names   )   )
												self.assertEqual(timm_model.channels   ,					transformers_model.channels   )
												# Out indices are set to the last layer by default. For timm models, we don't know
												# the number of layers in advance, so we set it to (-1,), whereas for transformers
												# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
												self.assertEqual(timm_model.out_indices   ,					(-1,)   )
												self.assertEqual(transformers_model.out_indices   ,					[len(timm_model.stage_names   ) - 1]   )

												lowerCamelCase_							  =					AutoBackbone.from_pretrained(__UpperCamelCase   ,					use_timm_backbone=__UpperCamelCase   ,					out_indices=[1, 2, 3]   )
												lowerCamelCase_							  =					AutoBackbone.from_pretrained(__UpperCamelCase   ,					out_indices=[1, 2, 3]   )

												self.assertEqual(timm_model.out_indices   ,					transformers_model.out_indices   )
												self.assertEqual(len(timm_model.out_features   )   ,					len(transformers_model.out_features   )   )
												self.assertEqual(timm_model.channels   ,					transformers_model.channels   )

					@unittest.skip("""TimmBackbone doesn't support feed forward chunking"""   )
					def    lowercase__      (	self					:     Optional[int]   ):
												pass

					@unittest.skip("""TimmBackbone doesn't have num_hidden_layers attribute"""   )
					def    lowercase__      (	self					:     List[Any]   ):
												pass

					@unittest.skip("""TimmBackbone initialization is managed on the timm side"""   )
					def    lowercase__      (	self					:     Dict   ):
												pass

					@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""   )
					def    lowercase__      (	self					:     Union[str, Any]   ):
												pass

					@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""   )
					def    lowercase__      (	self					:     Optional[Any]   ):
												pass

					@unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint"""   )
					def    lowercase__      (	self					:     Any   ):
												pass

					@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""   )
					def    lowercase__      (	self					:     Any   ):
												pass

					@unittest.skip("""model weights aren't tied in TimmBackbone."""   )
					def    lowercase__      (	self					:     Optional[int]   ):
												pass

					@unittest.skip("""model weights aren't tied in TimmBackbone."""   )
					def    lowercase__      (	self					:     List[Any]   ):
												pass

					@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""   )
					def    lowercase__      (	self					:     str   ):
												pass

					@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""   )
					def    lowercase__      (	self					:     List[Any]   ):
												pass

					@unittest.skip("""TimmBackbone doesn't have hidden size info in its configuration."""   )
					def    lowercase__      (	self					:     Optional[int]   ):
												pass

					@unittest.skip("""TimmBackbone doesn't support output_attentions."""   )
					def    lowercase__      (	self					:     List[Any]   ):
												pass

					@unittest.skip("""Safetensors is not supported by timm."""   )
					def    lowercase__      (	self					:     List[Any]   ):
												pass

					@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""   )
					def    lowercase__      (	self					:     Optional[int]   ):
												pass

					def    lowercase__      (	self					:     str   ):
												lowerCamelCase_  ,   lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																			lowerCamelCase_							  =					model_class(__UpperCamelCase   )
																			lowerCamelCase_							  =					inspect.signature(model.forward   )
																			# signature.parameters is an OrderedDict => so arg_names order is deterministic
																			lowerCamelCase_							  =					[*signature.parameters.keys()]

																			lowerCamelCase_							  =					["""pixel_values"""]
																			self.assertListEqual(arg_names[:1]   ,					__UpperCamelCase   )

					def    lowercase__      (	self					:     List[Any]   ):
												lowerCamelCase_  ,   lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs_for_common()
												lowerCamelCase_							  =					True
												lowerCamelCase_							  =					self.has_attentions

												# no need to test all models as different heads yield the same functionality
												lowerCamelCase_							  =					self.all_model_classes[0]
												lowerCamelCase_							  =					model_class(__UpperCamelCase   )
												model.to(__UpperCamelCase   )

												lowerCamelCase_							  =					self._prepare_for_class(__UpperCamelCase   ,					__UpperCamelCase   )
												lowerCamelCase_							  =					model(**__UpperCamelCase   )
												lowerCamelCase_							  =					outputs[0][-1]

												# Encoder-/Decoder-only models
												lowerCamelCase_							  =					outputs.hidden_states[0]
												hidden_states.retain_grad()

												if self.has_attentions:
																			lowerCamelCase_							  =					outputs.attentions[0]
																			attentions.retain_grad()

												output.flatten()[0].backward(retain_graph=__UpperCamelCase   )

												self.assertIsNotNone(hidden_states.grad   )

												if self.has_attentions:
																			self.assertIsNotNone(attentions.grad   )



					def    lowercase__      (	self					:     Optional[int]   ):
												lowerCamelCase_  ,   lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																			lowerCamelCase_							  =					model_class(__UpperCamelCase   )
																			model.to(__UpperCamelCase   )
																			model.eval()
																			lowerCamelCase_							  =					model(**__UpperCamelCase   )

																			self.assertEqual(len(result.feature_maps   )   ,					len(config.out_indices   )   )
																			self.assertEqual(len(model.channels   )   ,					len(config.out_indices   )   )

																			# Check output of last stage is taken if out_features=None, out_indices=None
																			lowerCamelCase_							  =					copy.deepcopy(__UpperCamelCase   )
																			lowerCamelCase_							  =					None
																			lowerCamelCase_							  =					model_class(__UpperCamelCase   )
																			model.to(__UpperCamelCase   )
																			model.eval()
																			lowerCamelCase_							  =					model(**__UpperCamelCase   )

																			self.assertEqual(len(result.feature_maps   )   ,					1   )
																			self.assertEqual(len(model.channels   )   ,					1   )

																			# Check backbone can be initialized with fresh weights
																			lowerCamelCase_							  =					copy.deepcopy(__UpperCamelCase   )
																			lowerCamelCase_							  =					False
																			lowerCamelCase_							  =					model_class(__UpperCamelCase   )
																			model.to(__UpperCamelCase   )
																			model.eval()
																			lowerCamelCase_							  =					model(**__UpperCamelCase   )







from __future__ import annotations

import unittest

from transformers import 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, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import numpy
		import tensorflow as tf

		from transformers import (
		    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    BertConfig,
		    DPRConfig,
		    TFDPRContextEncoder,
		    TFDPRQuestionEncoder,
		    TFDPRReader,
		)





class       __A:

					def __init__(	self					:     str   ,					__UpperCamelCase					:     Dict   ,					__UpperCamelCase					:     Any=1_3   ,					__UpperCamelCase					:     Dict=7   ,					__UpperCamelCase					:     int=True   ,					__UpperCamelCase					:     Optional[Any]=True   ,					__UpperCamelCase					:     Optional[Any]=True   ,					__UpperCamelCase					:     Dict=True   ,					__UpperCamelCase					:     Dict=9_9   ,					__UpperCamelCase					:     Optional[int]=3_2   ,					__UpperCamelCase					:     List[Any]=2   ,					__UpperCamelCase					:     Optional[int]=4   ,					__UpperCamelCase					:     List[Any]=3_7   ,					__UpperCamelCase					:     Optional[Any]="gelu"   ,					__UpperCamelCase					:     List[str]=0.1   ,					__UpperCamelCase					:     Any=0.1   ,					__UpperCamelCase					:     int=5_1_2   ,					__UpperCamelCase					:     List[Any]=1_6   ,					__UpperCamelCase					:     List[Any]=2   ,					__UpperCamelCase					:     List[str]=0.02   ,					__UpperCamelCase					:     Any=3   ,					__UpperCamelCase					:     int=4   ,					__UpperCamelCase					:     Optional[Any]=None   ,					__UpperCamelCase					:     Union[str, Any]=0   ,					):
												lowerCamelCase_							  =					parent
												lowerCamelCase_							  =					batch_size
												lowerCamelCase_							  =					seq_length
												lowerCamelCase_							  =					is_training
												lowerCamelCase_							  =					use_input_mask
												lowerCamelCase_							  =					use_token_type_ids
												lowerCamelCase_							  =					use_labels
												lowerCamelCase_							  =					vocab_size
												lowerCamelCase_							  =					hidden_size
												lowerCamelCase_							  =					num_hidden_layers
												lowerCamelCase_							  =					num_attention_heads
												lowerCamelCase_							  =					intermediate_size
												lowerCamelCase_							  =					hidden_act
												lowerCamelCase_							  =					hidden_dropout_prob
												lowerCamelCase_							  =					attention_probs_dropout_prob
												lowerCamelCase_							  =					max_position_embeddings
												lowerCamelCase_							  =					type_vocab_size
												lowerCamelCase_							  =					type_sequence_label_size
												lowerCamelCase_							  =					initializer_range
												lowerCamelCase_							  =					num_labels
												lowerCamelCase_							  =					num_choices
												lowerCamelCase_							  =					scope
												lowerCamelCase_							  =					projection_dim

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

												lowerCamelCase_							  =					None
												if self.use_input_mask:
																			# follow test_modeling_tf_ctrl.py
																			lowerCamelCase_							  =					random_attention_mask([self.batch_size, self.seq_length]   )

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

												lowerCamelCase_							  =					None
												lowerCamelCase_							  =					None
												lowerCamelCase_							  =					None
												if self.use_labels:
																			lowerCamelCase_							  =					ids_tensor([self.batch_size]   ,					self.type_sequence_label_size   )
																			lowerCamelCase_							  =					ids_tensor([self.batch_size, self.seq_length]   ,					self.num_labels   )
																			lowerCamelCase_							  =					ids_tensor([self.batch_size]   ,					self.num_choices   )

												lowerCamelCase_							  =					BertConfig(
												    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=__UpperCamelCase   ,					initializer_range=self.initializer_range   ,					)
												lowerCamelCase_							  =					DPRConfig(projection_dim=self.projection_dim   ,					**config.to_dict()   )

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

					def    lowercase__      (	self					:     Optional[Any]   ,					__UpperCamelCase					:     int   ,					__UpperCamelCase					:     Optional[Any]   ,					__UpperCamelCase					:     Any   ,					__UpperCamelCase					:     Optional[int]   ,					__UpperCamelCase					:     Optional[int]   ,					__UpperCamelCase					:     List[str]   ,					__UpperCamelCase					:     Union[str, Any]   ):
												lowerCamelCase_							  =					TFDPRContextEncoder(config=__UpperCamelCase   )
												lowerCamelCase_							  =					model(__UpperCamelCase   ,					attention_mask=__UpperCamelCase   ,					token_type_ids=__UpperCamelCase   )
												lowerCamelCase_							  =					model(__UpperCamelCase   ,					token_type_ids=__UpperCamelCase   )
												lowerCamelCase_							  =					model(__UpperCamelCase   )
												self.parent.assertEqual(result.pooler_output.shape   ,					(self.batch_size, self.projection_dim or self.hidden_size)   )

					def    lowercase__      (	self					:     str   ,					__UpperCamelCase					:     List[Any]   ,					__UpperCamelCase					:     Tuple   ,					__UpperCamelCase					:     Optional[int]   ,					__UpperCamelCase					:     Any   ,					__UpperCamelCase					:     Union[str, Any]   ,					__UpperCamelCase					:     List[Any]   ,					__UpperCamelCase					:     Union[str, Any]   ):
												lowerCamelCase_							  =					TFDPRQuestionEncoder(config=__UpperCamelCase   )
												lowerCamelCase_							  =					model(__UpperCamelCase   ,					attention_mask=__UpperCamelCase   ,					token_type_ids=__UpperCamelCase   )
												lowerCamelCase_							  =					model(__UpperCamelCase   ,					token_type_ids=__UpperCamelCase   )
												lowerCamelCase_							  =					model(__UpperCamelCase   )
												self.parent.assertEqual(result.pooler_output.shape   ,					(self.batch_size, self.projection_dim or self.hidden_size)   )

					def    lowercase__      (	self					:     str   ,					__UpperCamelCase					:     Optional[Any]   ,					__UpperCamelCase					:     Tuple   ,					__UpperCamelCase					:     Optional[int]   ,					__UpperCamelCase					:     Tuple   ,					__UpperCamelCase					:     Any   ,					__UpperCamelCase					:     Any   ,					__UpperCamelCase					:     List[str]   ):
												lowerCamelCase_							  =					TFDPRReader(config=__UpperCamelCase   )
												lowerCamelCase_							  =					model(__UpperCamelCase   ,					attention_mask=__UpperCamelCase   )

												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)   )
												self.parent.assertEqual(result.relevance_logits.shape   ,					(self.batch_size,)   )



					def    lowercase__      (	self					:     Dict   ):
												lowerCamelCase_							  =					self.prepare_config_and_inputs()
												(
												    (
												    lowerCamelCase_
												)  ,   (
												    lowerCamelCase_
												)  ,   (
												    lowerCamelCase_
												)  ,   (
												    lowerCamelCase_
												)  ,   (
												    lowerCamelCase_
												)  ,   (
												    lowerCamelCase_
												)  ,   (
												    lowerCamelCase_
												)  ,   
												)							  =					config_and_inputs
												lowerCamelCase_							  =					{"""input_ids""": input_ids}
												return config, inputs_dict





@require_tf
class       __A(				UpperCAmelCase     ,		UpperCAmelCase     ,		unittest.TestCase       ):
					SCREAMING_SNAKE_CASE			    =    (
					    (
					        TFDPRContextEncoder,
					        TFDPRQuestionEncoder,
					        TFDPRReader,
					    )
					    if is_tf_available()
					    else ()
					)
					SCREAMING_SNAKE_CASE			    =    {'''feature-extraction''': TFDPRQuestionEncoder} if is_tf_available() else {}

					SCREAMING_SNAKE_CASE			    =    False
					SCREAMING_SNAKE_CASE			    =    False
					SCREAMING_SNAKE_CASE			    =    False
					SCREAMING_SNAKE_CASE			    =    False
					SCREAMING_SNAKE_CASE			    =    False

					def    lowercase__      (	self					:     Dict   ):
												lowerCamelCase_							  =					TFDPRModelTester(self   )
												lowerCamelCase_							  =					ConfigTester(self   ,					config_class=__UpperCamelCase   ,					hidden_size=3_7   )

					def    lowercase__      (	self					:     Optional[Any]   ):
												self.config_tester.run_common_tests()

					def    lowercase__      (	self					:     Any   ):
												lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_dpr_context_encoder(*__UpperCamelCase   )

					def    lowercase__      (	self					:     Dict   ):
												lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_dpr_question_encoder(*__UpperCamelCase   )

					def    lowercase__      (	self					:     List[str]   ):
												lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_dpr_reader(*__UpperCamelCase   )



					@slow
					def    lowercase__      (	self					:     Optional[int]   ):
												for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			lowerCamelCase_							  =					TFDPRContextEncoder.from_pretrained(__UpperCamelCase   )
																			self.assertIsNotNone(__UpperCamelCase   )

												for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			lowerCamelCase_							  =					TFDPRContextEncoder.from_pretrained(__UpperCamelCase   )
																			self.assertIsNotNone(__UpperCamelCase   )

												for model_name in TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			lowerCamelCase_							  =					TFDPRQuestionEncoder.from_pretrained(__UpperCamelCase   )
																			self.assertIsNotNone(__UpperCamelCase   )

												for model_name in TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			lowerCamelCase_							  =					TFDPRReader.from_pretrained(__UpperCamelCase   )
																			self.assertIsNotNone(__UpperCamelCase   )





@require_tf
class       __A(				unittest.TestCase       ):

					@slow
					def    lowercase__      (	self					:     Union[str, Any]   ):
												lowerCamelCase_							  =					TFDPRQuestionEncoder.from_pretrained("""facebook/dpr-question_encoder-single-nq-base"""   )

												lowerCamelCase_							  =					tf.constant(
												    [[1_0_1, 7_5_9_2, 1_0_1_0, 2_0_0_3, 2_0_2_6, 3_8_9_9, 1_0_1_4_0, 1_0_2_9, 1_0_2]]   )  # [CLS] hello, is my dog cute? [SEP]
												lowerCamelCase_							  =					model(__UpperCamelCase   )[0]  # embedding shape = (1, 768)
												# compare the actual values for a slice.
												lowerCamelCase_							  =					tf.constant(
												    [
												        [
												            0.03236253,
												            0.12753335,
												            0.16818509,
												            0.00279786,
												            0.3896933,
												            0.24264945,
												            0.2178971,
												            -0.02335227,
												            -0.08481959,
												            -0.14324117,
												        ]
												    ]   )
												self.assertTrue(numpy.allclose(output[:, :1_0].numpy()   ,					expected_slice.numpy()   ,					atol=1E-4   )   )





