



import inspect
import unittest

from transformers import ViTConfig
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_gpu,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
							import torch
							from torch import nn

							from transformers import ViTForImageClassification, ViTForMaskedImageModeling, ViTModel
							from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import ViTImageProcessor



class  lowerCamelCase__    :




		'''simple docstring'''



		def __init__(self	,__lowerCamelCase	,__lowerCamelCase=13	,__lowerCamelCase=30	,__lowerCamelCase=2	,__lowerCamelCase=3	,__lowerCamelCase=True	,__lowerCamelCase=True	,__lowerCamelCase=32	,__lowerCamelCase=5	,__lowerCamelCase=4	,__lowerCamelCase=37	,__lowerCamelCase="gelu"	,__lowerCamelCase=0.1	,__lowerCamelCase=0.1	,__lowerCamelCase=10	,__lowerCamelCase=0.02	,__lowerCamelCase=None	,__lowerCamelCase=2	,)  ->    Optional[Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  parent
						lowerCAmelCase__  :       str				=  batch_size
						lowerCAmelCase__  :       Dict				=  image_size
						lowerCAmelCase__  :       int				=  patch_size
						lowerCAmelCase__  :       Optional[Any]				=  num_channels
						lowerCAmelCase__  :       Dict				=  is_training
						lowerCAmelCase__  :       Tuple				=  use_labels
						lowerCAmelCase__  :       str				=  hidden_size
						lowerCAmelCase__  :       Any				=  num_hidden_layers
						lowerCAmelCase__  :       int				=  num_attention_heads
						lowerCAmelCase__  :       Union[str, Any]				=  intermediate_size
						lowerCAmelCase__  :       str				=  hidden_act
						lowerCAmelCase__  :       Optional[int]				=  hidden_dropout_prob
						lowerCAmelCase__  :       Dict				=  attention_probs_dropout_prob
						lowerCAmelCase__  :       List[str]				=  type_sequence_label_size
						lowerCAmelCase__  :       int				=  initializer_range
						lowerCAmelCase__  :       Any				=  scope
						lowerCAmelCase__  :       Tuple				=  encoder_stride

						# in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
						lowerCAmelCase__  :       Optional[Any]				=  (image_size // patch_size) ** 2
						lowerCAmelCase__  :       str				=  num_patches + 1



		def 	lowerCAmelCase__   (self				)  ->    Dict:

						"""simple docstring"""






						lowerCAmelCase__  :       int				=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

						lowerCAmelCase__  :       Union[str, Any]				=  None
						if self.use_labels:
										lowerCAmelCase__  :       Optional[int]				=  ids_tensor([self.batch_size]	,self.type_sequence_label_size				)

						lowerCAmelCase__  :       Dict				=  self.get_config()

						return config, pixel_values, labels



		def 	lowerCAmelCase__   (self				)  ->    int:

						"""simple docstring"""






						return ViTConfig(
						    image_size=self.image_size	,patch_size=self.patch_size	,num_channels=self.num_channels	,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	,is_decoder=__lowerCamelCase	,initializer_range=self.initializer_range	,encoder_stride=self.encoder_stride	,)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    Dict:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  ViTModel(config=__lowerCamelCase				)
						model.to(__lowerCamelCase				)
						model.eval()
						lowerCAmelCase__  :       List[str]				=  model(__lowerCamelCase				)
						self.parent.assertEqual(result.last_hidden_state.shape	,(self.batch_size, self.seq_length, self.hidden_size)				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    Dict:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  ViTForMaskedImageModeling(config=__lowerCamelCase				)
						model.to(__lowerCamelCase				)
						model.eval()
						lowerCAmelCase__  :       int				=  model(__lowerCamelCase				)
						self.parent.assertEqual(
						    result.reconstruction.shape	,(self.batch_size, self.num_channels, self.image_size, self.image_size)				)

						# test greyscale images
						lowerCAmelCase__  :       Dict				=  1
						lowerCAmelCase__  :       List[Any]				=  ViTForMaskedImageModeling(__lowerCamelCase				)
						model.to(__lowerCamelCase				)
						model.eval()

						lowerCAmelCase__  :       str				=  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
						lowerCAmelCase__  :       int				=  model(__lowerCamelCase				)
						self.parent.assertEqual(result.reconstruction.shape	,(self.batch_size, 1, self.image_size, self.image_size)				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       int				=  self.type_sequence_label_size
						lowerCAmelCase__  :       Dict				=  ViTForImageClassification(__lowerCamelCase				)
						model.to(__lowerCamelCase				)
						model.eval()
						lowerCAmelCase__  :       str				=  model(__lowerCamelCase	,labels=__lowerCamelCase				)
						self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.type_sequence_label_size)				)

						# test greyscale images
						lowerCAmelCase__  :       str				=  1
						lowerCAmelCase__  :       Optional[Any]				=  ViTForImageClassification(__lowerCamelCase				)
						model.to(__lowerCamelCase				)
						model.eval()

						lowerCAmelCase__  :       List[Any]				=  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
						lowerCAmelCase__  :       Any				=  model(__lowerCamelCase				)
						self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.type_sequence_label_size)				)



		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       Tuple				=  self.prepare_config_and_inputs()
						(
						    (
						    lowerCAmelCase__
						)		,	(
						    lowerCAmelCase__
						)		,	(
						    lowerCAmelCase__
						)		,	
						)  :       Tuple				=  config_and_inputs
						lowerCAmelCase__  :       Any				=  {'''pixel_values''': pixel_values}
						return config, inputs_dict



@require_torch
class  lowerCamelCase__    (							lowerCamelCase__   ,       lowerCamelCase__   ,       unittest.TestCase):




		'''simple docstring'''



		snake_case_			=(
		    (
		        ViTModel,
		        ViTForImageClassification,
		        ViTForMaskedImageModeling,
		    )
		    if is_torch_available()
		    else ()
		)
		snake_case_			=(
		    {"""feature-extraction""": ViTModel, """image-classification""": ViTForImageClassification}
		    if is_torch_available()
		    else {}
		)
		snake_case_			=True

		snake_case_			=False
		snake_case_			=False
		snake_case_			=False



		def 	lowerCAmelCase__   (self				)  ->    Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  ViTModelTester(self				)
						lowerCAmelCase__  :       Dict				=  ConfigTester(self	,config_class=__lowerCamelCase	,has_text_modality=__lowerCamelCase	,hidden_size=37				)



		def 	lowerCAmelCase__   (self				)  ->    str:

						"""simple docstring"""






						self.config_tester.run_common_tests()



		@unittest.skip(reason='''ViT does not use inputs_embeds'''				)
		def 	lowerCAmelCase__   (self				)  ->    Optional[Any]:

						"""simple docstring"""






						pass



		def 	lowerCAmelCase__   (self				)  ->    int:

						"""simple docstring"""






						lowerCAmelCase__		,	lowerCAmelCase__  :       List[str]				=  self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
										lowerCAmelCase__  :       Optional[int]				=  model_class(__lowerCamelCase				)
										self.assertIsInstance(model.get_input_embeddings()	,(nn.Module)				)
										lowerCAmelCase__  :       Optional[int]				=  model.get_output_embeddings()
										self.assertTrue(x is None or isinstance(__lowerCamelCase	,nn.Linear				)				)



		def 	lowerCAmelCase__   (self				)  ->    Dict:

						"""simple docstring"""






						lowerCAmelCase__		,	lowerCAmelCase__  :       List[str]				=  self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
										lowerCAmelCase__  :       Optional[int]				=  model_class(__lowerCamelCase				)
										lowerCAmelCase__  :       str				=  inspect.signature(model.forward				)
										# signature.parameters is an OrderedDict => so arg_names order is deterministic
										lowerCAmelCase__  :       Tuple				=  [*signature.parameters.keys()]

										lowerCAmelCase__  :       Any				=  ['''pixel_values''']
										self.assertListEqual(arg_names[:1]	,__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[Any]				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_image_modeling(*__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    str:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[Any]				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase				)



		@slow
		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowerCAmelCase__  :       Optional[int]				=  ViTModel.from_pretrained(__lowerCamelCase				)
										self.assertIsNotNone(__lowerCamelCase				)






def 			lowerCAmelCase__	(					):





				'''simple docstring'''

				lowerCAmelCase__  :       int				=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
				return image



@require_torch
@require_vision
class  lowerCamelCase__    (							unittest.TestCase):




		'''simple docstring'''



		@cached_property
		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						return ViTImageProcessor.from_pretrained('''google/vit-base-patch16-224'''				) if is_vision_available() else None



		@slow
		def 	lowerCAmelCase__   (self				)  ->    Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  ViTForImageClassification.from_pretrained('''google/vit-base-patch16-224'''				).to(__lowerCamelCase				)

						lowerCAmelCase__  :       Tuple				=  self.default_image_processor
						lowerCAmelCase__  :       Any				=  prepare_img()
						lowerCAmelCase__  :       List[str]				=  image_processor(images=__lowerCamelCase	,return_tensors='''pt'''				).to(__lowerCamelCase				)

						# forward pass
						with torch.no_grad():
										lowerCAmelCase__  :       Optional[int]				=  model(**__lowerCamelCase				)

						# verify the logits
						lowerCAmelCase__  :       Union[str, Any]				=  torch.Size((1, 10_00)				)
						self.assertEqual(outputs.logits.shape	,__lowerCamelCase				)

						lowerCAmelCase__  :       List[str]				=  torch.tensor([-0.2744, 0.8215, -0.0836]				).to(__lowerCamelCase				)

						self.assertTrue(torch.allclose(outputs.logits[0, :3]	,__lowerCamelCase	,atol=1e-4				)				)



		@slow
		def 	lowerCAmelCase__   (self				)  ->    Optional[int]:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  ViTModel.from_pretrained('''facebook/dino-vits8'''				).to(__lowerCamelCase				)

						lowerCAmelCase__  :       Tuple				=  ViTImageProcessor.from_pretrained('''facebook/dino-vits8'''	,size=4_80				)
						lowerCAmelCase__  :       Optional[Any]				=  prepare_img()
						lowerCAmelCase__  :       str				=  image_processor(images=__lowerCamelCase	,return_tensors='''pt'''				)
						lowerCAmelCase__  :       Tuple				=  inputs.pixel_values.to(__lowerCamelCase				)

						# forward pass
						with torch.no_grad():
										lowerCAmelCase__  :       Optional[int]				=  model(__lowerCamelCase	,interpolate_pos_encoding=__lowerCamelCase				)

						# verify the logits
						lowerCAmelCase__  :       Optional[int]				=  torch.Size((1, 36_01, 3_84)				)
						self.assertEqual(outputs.last_hidden_state.shape	,__lowerCamelCase				)

						lowerCAmelCase__  :       List[str]				=  torch.tensor(
						    [[4.2340, 4.3906, -6.6692], [4.5463, 1.8928, -6.7257], [4.4429, 0.8496, -5.8585]]				).to(__lowerCamelCase				)

						self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]	,__lowerCamelCase	,atol=1e-4				)				)



		@slow
		@require_accelerate
		@require_torch_gpu
		def 	lowerCAmelCase__   (self				)  ->    Tuple:

						"""simple docstring"""






						lowerCAmelCase__  :       Tuple				=  ViTModel.from_pretrained('''facebook/dino-vits8'''	,torch_dtype=torch.floataa	,device_map='''auto'''				)
						lowerCAmelCase__  :       Optional[int]				=  self.default_image_processor

						lowerCAmelCase__  :       str				=  prepare_img()
						lowerCAmelCase__  :       Any				=  image_processor(images=__lowerCamelCase	,return_tensors='''pt'''				)
						lowerCAmelCase__  :       Optional[int]				=  inputs.pixel_values.to(__lowerCamelCase				)

						# forward pass to make sure inference works in fp16
						with torch.no_grad():
										lowerCAmelCase__  :       Tuple				=  model(__lowerCamelCase				)






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


__snake_case       :	str            =logging.get_logger(__name__)


if is_vision_available():
							import PIL



class  lowerCamelCase__    (							lowerCamelCase__):




		'''simple docstring'''



		snake_case_			=["""pixel_values"""]



		def __init__(self	,__lowerCamelCase = True	,__lowerCamelCase = None	,__lowerCamelCase = PILImageResampling.BICUBIC	,__lowerCamelCase = True	,__lowerCamelCase = None	,__lowerCamelCase = True	,__lowerCamelCase = 1 / 2_55	,__lowerCamelCase = True	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = True	,**__lowerCamelCase	,)  ->    None:

						"""simple docstring"""






						super().__init__(**__lowerCamelCase				)
						lowerCAmelCase__  :       Union[str, Any]				=  size if size is not None else {'''shortest_edge''': 2_24}
						lowerCAmelCase__  :       Union[str, Any]				=  get_size_dict(__lowerCamelCase	,default_to_square=__lowerCamelCase				)
						lowerCAmelCase__  :       List[Any]				=  crop_size if crop_size is not None else {'''height''': 2_24, '''width''': 2_24}
						lowerCAmelCase__  :       Optional[int]				=  get_size_dict(__lowerCamelCase	,default_to_square=__lowerCamelCase	,param_name='''crop_size'''				)

						lowerCAmelCase__  :       Optional[int]				=  do_resize
						lowerCAmelCase__  :       Any				=  size
						lowerCAmelCase__  :       int				=  resample
						lowerCAmelCase__  :       Dict				=  do_center_crop
						lowerCAmelCase__  :       str				=  crop_size
						lowerCAmelCase__  :       Dict				=  do_rescale
						lowerCAmelCase__  :       Optional[Any]				=  rescale_factor
						lowerCAmelCase__  :       Dict				=  do_normalize
						lowerCAmelCase__  :       Tuple				=  image_mean if image_mean is not None else OPENAI_CLIP_MEAN
						lowerCAmelCase__  :       Union[str, Any]				=  image_std if image_std is not None else OPENAI_CLIP_STD
						lowerCAmelCase__  :       int				=  do_convert_rgb



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase = PILImageResampling.BICUBIC	,__lowerCamelCase = None	,**__lowerCamelCase	,)  ->    np.ndarray:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[int]				=  get_size_dict(__lowerCamelCase	,default_to_square=__lowerCamelCase				)
						if "shortest_edge" not in size:
										raise ValueError(f"""The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}"""				)
						lowerCAmelCase__  :       Optional[int]				=  get_resize_output_image_size(__lowerCamelCase	,size=size['''shortest_edge''']	,default_to_square=__lowerCamelCase				)
						return resize(__lowerCamelCase	,size=__lowerCamelCase	,resample=__lowerCamelCase	,data_format=__lowerCamelCase	,**__lowerCamelCase				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase = None	,**__lowerCamelCase	,)  ->    np.ndarray:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  get_size_dict(__lowerCamelCase				)
						if "height" not in size or "width" not in size:
										raise ValueError(f"""The `size` parameter must contain the keys (height, width). Got {size.keys()}"""				)
						return center_crop(__lowerCamelCase	,size=(size['''height'''], size['''width'''])	,data_format=__lowerCamelCase	,**__lowerCamelCase				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase = None	,**__lowerCamelCase	,)  ->    int:

						"""simple docstring"""






						return rescale(__lowerCamelCase	,scale=__lowerCamelCase	,data_format=__lowerCamelCase	,**__lowerCamelCase				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase = None	,**__lowerCamelCase	,)  ->    np.ndarray:

						"""simple docstring"""






						return normalize(__lowerCamelCase	,mean=__lowerCamelCase	,std=__lowerCamelCase	,data_format=__lowerCamelCase	,**__lowerCamelCase				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = None	,__lowerCamelCase = ChannelDimension.FIRST	,**__lowerCamelCase	,)  ->    PIL.Image.Image:

						"""simple docstring"""






						lowerCAmelCase__  :       Tuple				=  do_resize if do_resize is not None else self.do_resize
						lowerCAmelCase__  :       Tuple				=  size if size is not None else self.size
						lowerCAmelCase__  :       Any				=  get_size_dict(__lowerCamelCase	,param_name='''size'''	,default_to_square=__lowerCamelCase				)
						lowerCAmelCase__  :       Tuple				=  resample if resample is not None else self.resample
						lowerCAmelCase__  :       Dict				=  do_center_crop if do_center_crop is not None else self.do_center_crop
						lowerCAmelCase__  :       List[Any]				=  crop_size if crop_size is not None else self.crop_size
						lowerCAmelCase__  :       str				=  get_size_dict(__lowerCamelCase	,param_name='''crop_size'''	,default_to_square=__lowerCamelCase				)
						lowerCAmelCase__  :       Dict				=  do_rescale if do_rescale is not None else self.do_rescale
						lowerCAmelCase__  :       int				=  rescale_factor if rescale_factor is not None else self.rescale_factor
						lowerCAmelCase__  :       List[Any]				=  do_normalize if do_normalize is not None else self.do_normalize
						lowerCAmelCase__  :       Dict				=  image_mean if image_mean is not None else self.image_mean
						lowerCAmelCase__  :       int				=  image_std if image_std is not None else self.image_std
						lowerCAmelCase__  :       Dict				=  do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

						lowerCAmelCase__  :       Optional[int]				=  make_list_of_images(__lowerCamelCase				)

						if not valid_images(__lowerCamelCase				):
										raise ValueError(
										    '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
										    '''torch.Tensor, tf.Tensor or jax.ndarray.'''				)

						if do_resize and size is None:
										raise ValueError('''Size must be specified if do_resize is True.'''				)

						if do_center_crop and crop_size is None:
										raise ValueError('''Crop size must be specified if do_center_crop is True.'''				)

						if do_rescale and rescale_factor is None:
										raise ValueError('''Rescale factor must be specified if do_rescale is True.'''				)

						if do_normalize and (image_mean is None or image_std is None):
										raise ValueError('''Image mean and std must be specified if do_normalize is True.'''				)

						# PIL RGBA images are converted to RGB
						if do_convert_rgb:
										lowerCAmelCase__  :       Union[str, Any]				=  [convert_to_rgb(__lowerCamelCase				) for image in images]

						# All transformations expect numpy arrays.
						lowerCAmelCase__  :       Any				=  [to_numpy_array(__lowerCamelCase				) for image in images]

						if do_resize:
										lowerCAmelCase__  :       str				=  [self.resize(image=__lowerCamelCase	,size=__lowerCamelCase	,resample=__lowerCamelCase				) for image in images]

						if do_center_crop:
										lowerCAmelCase__  :       Dict				=  [self.center_crop(image=__lowerCamelCase	,size=__lowerCamelCase				) for image in images]

						if do_rescale:
										lowerCAmelCase__  :       Union[str, Any]				=  [self.rescale(image=__lowerCamelCase	,scale=__lowerCamelCase				) for image in images]

						if do_normalize:
										lowerCAmelCase__  :       Optional[Any]				=  [self.normalize(image=__lowerCamelCase	,mean=__lowerCamelCase	,std=__lowerCamelCase				) for image in images]

						lowerCAmelCase__  :       List[Any]				=  [to_channel_dimension_format(__lowerCamelCase	,__lowerCamelCase				) for image in images]

						lowerCAmelCase__  :       Optional[int]				=  {'''pixel_values''': images}
						return BatchFeature(data=__lowerCamelCase	,tensor_type=__lowerCamelCase				)

