




import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import TimesformerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, 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 (
      MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
      TimesformerForVideoClassification,
      TimesformerModel,
  )
  from transformers.models.timesformer.modeling_timesformer import TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from transformers import VideoMAEImageProcessor



class    UpperCAmelCase_	:
       '''simple docstring'''






       def __init__(     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE=13 ,					__SCREAMING_SNAKE_CASE=10 ,					__SCREAMING_SNAKE_CASE=3 ,					__SCREAMING_SNAKE_CASE=2 ,					__SCREAMING_SNAKE_CASE=2 ,					__SCREAMING_SNAKE_CASE=True ,					__SCREAMING_SNAKE_CASE=True ,					__SCREAMING_SNAKE_CASE=32 ,					__SCREAMING_SNAKE_CASE=5 ,					__SCREAMING_SNAKE_CASE=4 ,					__SCREAMING_SNAKE_CASE=37 ,					__SCREAMING_SNAKE_CASE="gelu" ,					__SCREAMING_SNAKE_CASE=0.1 ,					__SCREAMING_SNAKE_CASE=0.1 ,					__SCREAMING_SNAKE_CASE=10 ,					__SCREAMING_SNAKE_CASE=0.02 ,					__SCREAMING_SNAKE_CASE="divided_space_time" ,					__SCREAMING_SNAKE_CASE=None ,					):




              """simple docstring"""




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

              # in TimeSformer, the number of spatial tokens equals num_frames * num_patches per frame + 1 CLS token
              UpperCamelCase    :	List[str]   	=		(image_size // patch_size) ** 2
              UpperCamelCase    :	Union[str, Any]   	=		(num_frames) * self.num_patches_per_frame + 1






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Optional[Any]   	=		floats_tensor(
                  [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]						)

              UpperCamelCase    :	Union[str, Any]   	=		None
              if self.use_labels:
                     UpperCamelCase    :	Union[str, Any]   	=		ids_tensor([self.batch_size] ,					self.num_labels						)

              UpperCamelCase    :	int   	=		self.get_config()

              return config, pixel_values, labels






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	int   	=		TimesformerConfig(
                  image_size=self.image_size ,					patch_size=self.patch_size ,					num_channels=self.num_channels ,					num_frames=self.num_frames ,					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 ,					initializer_range=self.initializer_range ,					attention_type=self.attention_type ,					)
              UpperCamelCase    :	int   	=		self.num_labels
              return config






       def  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              UpperCamelCase    :	List[Any]   	=		TimesformerModel(config=UpperCAmelCase__						)
              model.to(UpperCAmelCase__						)
              model.eval()
              UpperCamelCase    :	int   	=		model(UpperCAmelCase__						)
              self.parent.assertEqual(result.last_hidden_state.shape ,					(self.batch_size, self.seq_length, self.hidden_size)						)






       def  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              UpperCamelCase    :	Union[str, Any]   	=		TimesformerForVideoClassification(UpperCAmelCase__						)
              model.to(UpperCAmelCase__						)
              model.eval()

              UpperCamelCase    :	List[str]   	=		model(UpperCAmelCase__						)

              # verify the logits shape
              UpperCamelCase    :	Union[str, Any]   	=		torch.Size((self.batch_size, self.num_labels)						)
              self.parent.assertEqual(result.logits.shape ,					UpperCAmelCase__						)






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Tuple   	=		self.prepare_config_and_inputs()
              UpperCamelCase    :	Any   	=		config_and_inputs
              UpperCamelCase    :	List[Any]   	=		{'''pixel_values''': pixel_values}
              return config, inputs_dict




@require_torch
class    UpperCAmelCase_	(							lowercase__,     lowercase__,     unittest.TestCase):
       '''simple docstring'''
       __UpperCamelCase      :     str							=					(TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
       __UpperCamelCase      :     Optional[Any]							=					(
           {"feature-extraction": TimesformerModel, "video-classification": TimesformerForVideoClassification}
           if is_torch_available()
           else {}
       )

       __UpperCamelCase      :     Optional[int]							=					False
       __UpperCamelCase      :     Dict							=					False
       __UpperCamelCase      :     List[str]							=					False
       __UpperCamelCase      :     Any							=					False






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	List[Any]   	=		TimesformerModelTester(self						)
              UpperCamelCase    :	str   	=		ConfigTester(
                  self ,					config_class=UpperCAmelCase__ ,					has_text_modality=UpperCAmelCase__ ,					hidden_size=37						)






       def  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE=False						):




              """simple docstring"""




              UpperCamelCase    :	int   	=		copy.deepcopy(UpperCAmelCase__						)

              if return_labels:
                     if model_class in get_values(UpperCAmelCase__						):
                            UpperCamelCase    :	Optional[Any]   	=		torch.zeros(
                                self.model_tester.batch_size ,					dtype=torch.long ,					device=UpperCAmelCase__						)

              return inputs_dict






       def  _lowercase   (     self						):




              """simple docstring"""




              self.config_tester.run_common_tests()






       @unittest.skip(reason='''TimeSformer does not use inputs_embeds'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       def  _lowercase   (     self						):




              """simple docstring"""




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

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






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	int   	=		self.model_tester.prepare_config_and_inputs_for_common()

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

                     UpperCamelCase    :	Any   	=		['''pixel_values''']
                     self.assertListEqual(arg_names[:1] ,					UpperCAmelCase__						)






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	List[Any]   	=		self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_model(*UpperCAmelCase__						)






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Tuple   	=		self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_video_classification(*UpperCAmelCase__						)






       @slow
       def  _lowercase   (     self						):




              """simple docstring"""




              for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     UpperCamelCase    :	Optional[Any]   	=		TimesformerModel.from_pretrained(UpperCAmelCase__						)
                     self.assertIsNotNone(UpperCAmelCase__						)






       def  _lowercase   (     self						):




              """simple docstring"""




              if not self.has_attentions:
                     pass

              else:
                     UpperCamelCase    :	Any   	=		self.model_tester.prepare_config_and_inputs_for_common()
                     UpperCamelCase    :	Optional[Any]   	=		True

                     for model_class in self.all_model_classes:
                            UpperCamelCase    :	List[Any]   	=		self.model_tester.seq_length
                            UpperCamelCase    :	List[Any]   	=		self.model_tester.num_frames

                            UpperCamelCase    :	Dict   	=		True
                            UpperCamelCase    :	int   	=		False
                            UpperCamelCase    :	Optional[Any]   	=		True
                            UpperCamelCase    :	Optional[int]   	=		model_class(UpperCAmelCase__						)
                            model.to(UpperCAmelCase__						)
                            model.eval()
                            with torch.no_grad():
                                   UpperCamelCase    :	Any   	=		model(**self._prepare_for_class(UpperCAmelCase__ ,					UpperCAmelCase__						)						)
                            UpperCamelCase    :	Any   	=		outputs.attentions
                            self.assertEqual(len(UpperCAmelCase__						) ,					self.model_tester.num_hidden_layers						)

                            # check that output_attentions also work using config
                            del inputs_dict["output_attentions"]
                            UpperCamelCase    :	Optional[int]   	=		True
                            UpperCamelCase    :	Optional[Any]   	=		model_class(UpperCAmelCase__						)
                            model.to(UpperCAmelCase__						)
                            model.eval()
                            with torch.no_grad():
                                   UpperCamelCase    :	Dict   	=		model(**self._prepare_for_class(UpperCAmelCase__ ,					UpperCAmelCase__						)						)
                            UpperCamelCase    :	Dict   	=		outputs.attentions
                            self.assertEqual(len(UpperCAmelCase__						) ,					self.model_tester.num_hidden_layers						)

                            # attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
                            self.assertListEqual(
                                list(attentions[0].shape[-3:]						) ,					[self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1] ,					)
                            UpperCamelCase    :	Optional[int]   	=		len(UpperCAmelCase__						)

                            # Check attention is always last and order is fine
                            UpperCamelCase    :	str   	=		True
                            UpperCamelCase    :	Union[str, Any]   	=		True
                            UpperCamelCase    :	Optional[int]   	=		model_class(UpperCAmelCase__						)
                            model.to(UpperCAmelCase__						)
                            model.eval()
                            with torch.no_grad():
                                   UpperCamelCase    :	Any   	=		model(**self._prepare_for_class(UpperCAmelCase__ ,					UpperCAmelCase__						)						)

                            self.assertEqual(out_len + 1 ,					len(UpperCAmelCase__						)						)

                            UpperCamelCase    :	Union[str, Any]   	=		outputs.attentions

                            self.assertEqual(len(UpperCAmelCase__						) ,					self.model_tester.num_hidden_layers						)

                            # attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
                            self.assertListEqual(
                                list(self_attentions[0].shape[-3:]						) ,					[self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1] ,					)






       def  _lowercase   (     self						):




              """simple docstring"""




              def check_hidden_states_output(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						):
                     UpperCamelCase    :	str   	=		model_class(UpperCAmelCase__						)
                     model.to(UpperCAmelCase__						)
                     model.eval()

                     with torch.no_grad():
                            UpperCamelCase    :	Dict   	=		model(**self._prepare_for_class(UpperCAmelCase__ ,					UpperCAmelCase__						)						)

                     UpperCamelCase    :	Optional[int]   	=		outputs.hidden_states
                     UpperCamelCase    :	List[str]   	=		self.model_tester.num_hidden_layers + 1
                     self.assertEqual(len(UpperCAmelCase__						) ,					UpperCAmelCase__						)

                     UpperCamelCase    :	Optional[int]   	=		self.model_tester.seq_length

                     self.assertListEqual(
                         list(hidden_states[0].shape[-2:]						) ,					[seq_length, self.model_tester.hidden_size] ,					)

              UpperCamelCase    :	Any   	=		self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     UpperCamelCase    :	Any   	=		True
                     check_hidden_states_output(UpperCAmelCase__ ,					UpperCAmelCase__ ,					UpperCAmelCase__						)

                     # check that output_hidden_states also work using config
                     del inputs_dict["output_hidden_states"]
                     UpperCamelCase    :	List[Any]   	=		True

                     check_hidden_states_output(UpperCAmelCase__ ,					UpperCAmelCase__ ,					UpperCAmelCase__						)




def      a	(							):






       """simple docstring"""





       UpperCamelCase    :	Union[str, Any]   	=		hf_hub_download(
           repo_id='''hf-internal-testing/spaghetti-video'''							,			filename='''eating_spaghetti.npy'''							,			repo_type='''dataset'''       )
       UpperCamelCase    :	str   	=		np.load(SCREAMING_SNAKE_CASE_       )
       return list(SCREAMING_SNAKE_CASE_       )



@require_torch
@require_vision
class    UpperCAmelCase_	(							unittest.TestCase):
       '''simple docstring'''






       @cached_property
       def  _lowercase   (     self						):




              """simple docstring"""




              return (
                  VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5] ,					image_std=[0.5, 0.5, 0.5]						)
                  if is_vision_available()
                  else None
              )






       @slow
       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Optional[int]   	=		TimesformerForVideoClassification.from_pretrained('''facebook/timesformer-base-finetuned-k400'''						).to(
                  UpperCAmelCase__						)

              UpperCamelCase    :	int   	=		self.default_image_processor
              UpperCamelCase    :	Tuple   	=		prepare_video()
              UpperCamelCase    :	Any   	=		image_processor(video[:8] ,					return_tensors='''pt'''						).to(UpperCAmelCase__						)

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

              # verify the logits
              UpperCamelCase    :	Any   	=		torch.Size((1, 400)						)
              self.assertEqual(outputs.logits.shape ,					UpperCAmelCase__						)

              UpperCamelCase    :	List[str]   	=		torch.tensor([-0.3_016, -0.7_713, -0.4_205]						).to(UpperCAmelCase__						)

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





import copy
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


__UpperCAmelCase : Optional[Any] 			=				logging.get_logger(__name__)

__UpperCAmelCase : List[str] 			=				{
    "microsoft/conditional-detr-resnet-50": (
        "https://huggingface.co/microsoft/conditional-detr-resnet-50/resolve/main/config.json"
    ),
}



class    UpperCAmelCase_	(							_a):
       '''simple docstring'''
       __UpperCamelCase      :     Optional[int]							=					"conditional_detr"
       __UpperCamelCase      :     Optional[Any]							=					["past_key_values"]
       __UpperCamelCase      :     Union[str, Any]							=					{
           "hidden_size": "d_model",
           "num_attention_heads": "encoder_attention_heads",
       }






       def __init__(     self ,					__SCREAMING_SNAKE_CASE=True ,					__SCREAMING_SNAKE_CASE=None ,					__SCREAMING_SNAKE_CASE=3 ,					__SCREAMING_SNAKE_CASE=300 ,					__SCREAMING_SNAKE_CASE=6 ,					__SCREAMING_SNAKE_CASE=2_048 ,					__SCREAMING_SNAKE_CASE=8 ,					__SCREAMING_SNAKE_CASE=6 ,					__SCREAMING_SNAKE_CASE=2_048 ,					__SCREAMING_SNAKE_CASE=8 ,					__SCREAMING_SNAKE_CASE=0.0 ,					__SCREAMING_SNAKE_CASE=0.0 ,					__SCREAMING_SNAKE_CASE=True ,					__SCREAMING_SNAKE_CASE="relu" ,					__SCREAMING_SNAKE_CASE=256 ,					__SCREAMING_SNAKE_CASE=0.1 ,					__SCREAMING_SNAKE_CASE=0.0 ,					__SCREAMING_SNAKE_CASE=0.0 ,					__SCREAMING_SNAKE_CASE=0.02 ,					__SCREAMING_SNAKE_CASE=1.0 ,					__SCREAMING_SNAKE_CASE=False ,					__SCREAMING_SNAKE_CASE="sine" ,					__SCREAMING_SNAKE_CASE="resnet50" ,					__SCREAMING_SNAKE_CASE=True ,					__SCREAMING_SNAKE_CASE=False ,					__SCREAMING_SNAKE_CASE=2 ,					__SCREAMING_SNAKE_CASE=5 ,					__SCREAMING_SNAKE_CASE=2 ,					__SCREAMING_SNAKE_CASE=1 ,					__SCREAMING_SNAKE_CASE=1 ,					__SCREAMING_SNAKE_CASE=2 ,					__SCREAMING_SNAKE_CASE=5 ,					__SCREAMING_SNAKE_CASE=2 ,					__SCREAMING_SNAKE_CASE=0.25 ,					**__SCREAMING_SNAKE_CASE ,					):




              """simple docstring"""




              if backbone_config is not None and use_timm_backbone:
                     raise ValueError('''You can\'t specify both `backbone_config` and `use_timm_backbone`.'''						)

              if not use_timm_backbone:
                     if backbone_config is None:
                            logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'''						)
                            UpperCamelCase    :	str   	=		CONFIG_MAPPING['''resnet'''](out_features=['''stage4''']						)
                     elif isinstance(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						):
                            UpperCamelCase    :	Tuple   	=		backbone_config.get('''model_type'''						)
                            UpperCamelCase    :	Optional[Any]   	=		CONFIG_MAPPING[backbone_model_type]
                            UpperCamelCase    :	Any   	=		config_class.from_dict(__SCREAMING_SNAKE_CASE						)

              UpperCamelCase    :	List[str]   	=		use_timm_backbone
              UpperCamelCase    :	int   	=		backbone_config
              UpperCamelCase    :	Any   	=		num_channels
              UpperCamelCase    :	Optional[Any]   	=		num_queries
              UpperCamelCase    :	Tuple   	=		d_model
              UpperCamelCase    :	Optional[Any]   	=		encoder_ffn_dim
              UpperCamelCase    :	Optional[int]   	=		encoder_layers
              UpperCamelCase    :	Union[str, Any]   	=		encoder_attention_heads
              UpperCamelCase    :	Optional[Any]   	=		decoder_ffn_dim
              UpperCamelCase    :	Optional[int]   	=		decoder_layers
              UpperCamelCase    :	Optional[Any]   	=		decoder_attention_heads
              UpperCamelCase    :	Any   	=		dropout
              UpperCamelCase    :	List[Any]   	=		attention_dropout
              UpperCamelCase    :	List[Any]   	=		activation_dropout
              UpperCamelCase    :	List[str]   	=		activation_function
              UpperCamelCase    :	Optional[int]   	=		init_std
              UpperCamelCase    :	Optional[Any]   	=		init_xavier_std
              UpperCamelCase    :	Union[str, Any]   	=		encoder_layerdrop
              UpperCamelCase    :	Optional[Any]   	=		decoder_layerdrop
              UpperCamelCase    :	Tuple   	=		encoder_layers
              UpperCamelCase    :	Optional[Any]   	=		auxiliary_loss
              UpperCamelCase    :	Union[str, Any]   	=		position_embedding_type
              UpperCamelCase    :	Optional[int]   	=		backbone
              UpperCamelCase    :	Dict   	=		use_pretrained_backbone
              UpperCamelCase    :	Tuple   	=		dilation
              # Hungarian matcher
              UpperCamelCase    :	Union[str, Any]   	=		class_cost
              UpperCamelCase    :	List[Any]   	=		bbox_cost
              UpperCamelCase    :	Optional[Any]   	=		giou_cost
              # Loss coefficients
              UpperCamelCase    :	Optional[Any]   	=		mask_loss_coefficient
              UpperCamelCase    :	Optional[int]   	=		dice_loss_coefficient
              UpperCamelCase    :	Optional[Any]   	=		cls_loss_coefficient
              UpperCamelCase    :	Optional[int]   	=		bbox_loss_coefficient
              UpperCamelCase    :	Optional[int]   	=		giou_loss_coefficient
              UpperCamelCase    :	Optional[int]   	=		focal_alpha
              super().__init__(is_encoder_decoder=__SCREAMING_SNAKE_CASE ,					**__SCREAMING_SNAKE_CASE						)






       @property
       def  _lowercase   (     self						):




              """simple docstring"""




              return self.encoder_attention_heads






       @property
       def  _lowercase   (     self						):




              """simple docstring"""




              return self.d_model






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Union[str, Any]   	=		copy.deepcopy(self.__dict__						)
              if self.backbone_config is not None:
                     UpperCamelCase    :	List[Any]   	=		self.backbone_config.to_dict()
              UpperCamelCase    :	List[Any]   	=		self.__class__.model_type
              return output




class    UpperCAmelCase_	(							_a):
       '''simple docstring'''
       __UpperCamelCase      :     Dict							=					version.parse("1.11")






       @property
       def  _lowercase   (     self						):




              """simple docstring"""




              return OrderedDict(
                  [
                      ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
                      ('''pixel_mask''', {0: '''batch'''}),
                  ]						)






       @property
       def  _lowercase   (     self						):




              """simple docstring"""




              return 1e-5






       @property
       def  _lowercase   (     self						):




              """simple docstring"""




              return 12

