




"""simple docstring"""






import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.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, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch
			from torch import nn

			from transformers import MaskFormerSwinBackbone
			from transformers.models.maskformer import MaskFormerSwinModel






class lowerCAmelCase__			:






			'''simple docstring'''



			def __init__(						self						,   lowercase						,   lowercase=13						,   lowercase=32						,   lowercase=2						,   lowercase=3						,   lowercase=16						,   lowercase=[1, 2, 1]						,   lowercase=[2, 2, 4]						,   lowercase=2						,   lowercase=2.0						,   lowercase=True						,   lowercase=0.0						,   lowercase=0.0						,   lowercase=0.1						,   lowercase="gelu"						,   lowercase=False						,   lowercase=True						,   lowercase=0.02						,   lowercase=1E-5						,   lowercase=True						,   lowercase=None						,   lowercase=True						,   lowercase=10						,   lowercase=8						,   lowercase=["stage1", "stage2", "stage3"]						,   lowercase=[1, 2, 3]						,   ):
							_lowerCamelCase  :    Any					=					parent
							_lowerCamelCase  :    int					=					batch_size
							_lowerCamelCase  :    Tuple					=					image_size
							_lowerCamelCase  :    str					=					patch_size
							_lowerCamelCase  :    Dict					=					num_channels
							_lowerCamelCase  :    List[str]					=					embed_dim
							_lowerCamelCase  :    Union[str, Any]					=					depths
							_lowerCamelCase  :    Optional[int]					=					num_heads
							_lowerCamelCase  :    int					=					window_size
							_lowerCamelCase  :    List[Any]					=					mlp_ratio
							_lowerCamelCase  :    Optional[int]					=					qkv_bias
							_lowerCamelCase  :    str					=					hidden_dropout_prob
							_lowerCamelCase  :    str					=					attention_probs_dropout_prob
							_lowerCamelCase  :    List[str]					=					drop_path_rate
							_lowerCamelCase  :    Optional[int]					=					hidden_act
							_lowerCamelCase  :    Optional[int]					=					use_absolute_embeddings
							_lowerCamelCase  :    Dict					=					patch_norm
							_lowerCamelCase  :    Any					=					layer_norm_eps
							_lowerCamelCase  :    List[str]					=					initializer_range
							_lowerCamelCase  :    Tuple					=					is_training
							_lowerCamelCase  :    List[str]					=					scope
							_lowerCamelCase  :    Dict					=					use_labels
							_lowerCamelCase  :    Any					=					type_sequence_label_size
							_lowerCamelCase  :    Any					=					encoder_stride
							_lowerCamelCase  :    Dict					=					out_features
							_lowerCamelCase  :    Dict					=					out_indices
			def       A_					(						self						):
							_lowerCamelCase  :    Tuple					=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

							_lowerCamelCase  :    Any					=					None
							if self.use_labels:
											_lowerCamelCase  :    List[str]					=					ids_tensor([self.batch_size]						,   self.type_sequence_label_size						)

							_lowerCamelCase  :    Optional[Any]					=					self.get_config()

							return config, pixel_values, labels
			def       A_					(						self						):
							return MaskFormerSwinConfig(
							    image_size=self.image_size						,   patch_size=self.patch_size						,   num_channels=self.num_channels						,   embed_dim=self.embed_dim						,   depths=self.depths						,   num_heads=self.num_heads						,   window_size=self.window_size						,   mlp_ratio=self.mlp_ratio						,   qkv_bias=self.qkv_bias						,   hidden_dropout_prob=self.hidden_dropout_prob						,   attention_probs_dropout_prob=self.attention_probs_dropout_prob						,   drop_path_rate=self.drop_path_rate						,   hidden_act=self.hidden_act						,   use_absolute_embeddings=self.use_absolute_embeddings						,   path_norm=self.patch_norm						,   layer_norm_eps=self.layer_norm_eps						,   initializer_range=self.initializer_range						,   encoder_stride=self.encoder_stride						,   out_features=self.out_features						,   out_indices=self.out_indices						,   )
			def       A_					(						self						,   lowercase						,   lowercase						,   lowercase						):
							_lowerCamelCase  :    Tuple					=					MaskFormerSwinModel(config=lowercase						)
							model.to(lowercase						)
							model.eval()
							_lowerCamelCase  :    str					=					model(lowercase						)

							_lowerCamelCase  :    Tuple					=					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths						) - 1))
							_lowerCamelCase  :    Optional[int]					=					int(config.embed_dim * 2 ** (len(config.depths						) - 1)						)

							self.parent.assertEqual(result.last_hidden_state.shape						,   (self.batch_size, expected_seq_len, expected_dim)						)
			def       A_					(						self						,   lowercase						,   lowercase						,   lowercase						):
							_lowerCamelCase  :    List[str]					=					MaskFormerSwinBackbone(config=lowercase						)
							model.to(lowercase						)
							model.eval()
							_lowerCamelCase  :    str					=					model(lowercase						)

							# verify feature maps
							self.parent.assertEqual(len(result.feature_maps						)						,   len(config.out_features						)						)
							self.parent.assertListEqual(list(result.feature_maps[0].shape						)						,   [13, 16, 16, 16]						)

							# verify channels
							self.parent.assertEqual(len(model.channels						)						,   len(config.out_features						)						)
							self.parent.assertListEqual(model.channels						,   [16, 32, 64]						)

							# verify ValueError
							with self.parent.assertRaises(lowercase						):
											_lowerCamelCase  :    List[str]					=					['stem']
											_lowerCamelCase  :    Dict					=					MaskFormerSwinBackbone(config=lowercase						)






			def       A_					(						self						):
							_lowerCamelCase  :    int					=					self.prepare_config_and_inputs()
							_lowerCamelCase,				_lowerCamelCase,				_lowerCamelCase  :    str					=					config_and_inputs
							_lowerCamelCase  :    int					=					{'pixel_values': pixel_values}
							return config, inputs_dict






@require_torch
class lowerCAmelCase__			(  lowercase,			lowercase,			unittest.TestCase		):






			'''simple docstring'''



			lowerCamelCase__   =    (
			    (
			        MaskFormerSwinModel,
			        MaskFormerSwinBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			lowerCamelCase__   =    {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
			lowerCamelCase__   =    False
			lowerCamelCase__   =    False
			lowerCamelCase__   =    False
			lowerCamelCase__   =    False
			lowerCamelCase__   =    False
			def       A_					(						self						):
							_lowerCamelCase  :    Optional[int]					=					MaskFormerSwinModelTester(self						)
							_lowerCamelCase  :    str					=					ConfigTester(self						,   config_class=lowercase						,   embed_dim=37						)
			@require_torch_multi_gpu
			@unittest.skip(
			    reason=(
			        '`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'
			        ' `nn.DataParallel`'
			    )						)
			def       A_					(						self						):
							pass
			def       A_					(						self						):
							self.create_and_test_config_common_properties()
							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       A_					(						self						):
							return
			def       A_					(						self						):
							_lowerCamelCase  :    Optional[int]					=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowercase						)
			def       A_					(						self						):
							_lowerCamelCase  :    Optional[Any]					=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*lowercase						)
			@unittest.skip('Swin does not use inputs_embeds'						)
			def       A_					(						self						):
							pass
			@unittest.skip('Swin does not support feedforward chunking'						)
			def       A_					(						self						):
							pass
			def       A_					(						self						):
							_lowerCamelCase,				_lowerCamelCase  :    Optional[int]					=					self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											_lowerCamelCase  :    str					=					model_class(lowercase						)
											self.assertIsInstance(model.get_input_embeddings()						,   (nn.Module)						)
											_lowerCamelCase  :    Any					=					model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(lowercase						,   nn.Linear						)						)
			def       A_					(						self						):
							_lowerCamelCase,				_lowerCamelCase  :    List[str]					=					self.model_tester.prepare_config_and_inputs_for_common()

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

											_lowerCamelCase  :    Union[str, Any]					=					['pixel_values']
											self.assertListEqual(arg_names[:1]						,   lowercase						)
			@unittest.skip(reason='MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'						)
			def       A_					(						self						):
							pass
			@unittest.skip(reason='MaskFormerSwin is only used as an internal backbone'						)
			def       A_					(						self						):
							pass
			def       A_					(						self						,   lowercase						,   lowercase						,   lowercase						,   lowercase						):
							_lowerCamelCase  :    List[Any]					=					model_class(lowercase						)
							model.to(lowercase						)
							model.eval()

							with torch.no_grad():
											_lowerCamelCase  :    Tuple					=					model(**self._prepare_for_class(lowercase						,   lowercase						)						)

							_lowerCamelCase  :    Tuple					=					outputs.hidden_states

							_lowerCamelCase  :    str					=					getattr(
							    self.model_tester						,   'expected_num_hidden_layers'						,   len(self.model_tester.depths						) + 1						)
							self.assertEqual(len(lowercase						)						,   lowercase						)

							# Swin has a different seq_length
							_lowerCamelCase  :    Union[str, Any]					=					(
							    config.patch_size
							    if isinstance(config.patch_size						,   collections.abc.Iterable						)
							    else (config.patch_size, config.patch_size)
							)

							_lowerCamelCase  :    Optional[int]					=					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

							self.assertListEqual(
							    list(hidden_states[0].shape[-2:]						)						,   [num_patches, self.model_tester.embed_dim]						,   )
			def       A_					(						self						):
							_lowerCamelCase,				_lowerCamelCase  :    Tuple					=					self.model_tester.prepare_config_and_inputs_for_common()

							_lowerCamelCase  :    Optional[int]					=					(
							    self.model_tester.image_size
							    if isinstance(self.model_tester.image_size						,   collections.abc.Iterable						)
							    else (self.model_tester.image_size, self.model_tester.image_size)
							)

							for model_class in self.all_model_classes:
											_lowerCamelCase  :    Dict					=					True
											self.check_hidden_states_output(lowercase						,   lowercase						,   lowercase						,   lowercase						)

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											_lowerCamelCase  :    str					=					True

											self.check_hidden_states_output(lowercase						,   lowercase						,   lowercase						,   lowercase						)
			def       A_					(						self						):
							_lowerCamelCase,				_lowerCamelCase  :    Any					=					self.model_tester.prepare_config_and_inputs_for_common()
							_lowerCamelCase  :    Optional[Any]					=					3

							_lowerCamelCase  :    Any					=					(
							    self.model_tester.image_size
							    if isinstance(self.model_tester.image_size						,   collections.abc.Iterable						)
							    else (self.model_tester.image_size, self.model_tester.image_size)
							)
							_lowerCamelCase  :    Optional[int]					=					(
							    config.patch_size
							    if isinstance(config.patch_size						,   collections.abc.Iterable						)
							    else (config.patch_size, config.patch_size)
							)

							_lowerCamelCase  :    List[Any]					=					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
							_lowerCamelCase  :    List[str]					=					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

							for model_class in self.all_model_classes:
											_lowerCamelCase  :    Optional[Any]					=					True
											self.check_hidden_states_output(lowercase						,   lowercase						,   lowercase						,   (padded_height, padded_width)						)

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											_lowerCamelCase  :    Optional[Any]					=					True
											self.check_hidden_states_output(lowercase						,   lowercase						,   lowercase						,   (padded_height, padded_width)						)
			@unittest.skip(reason='MaskFormerSwin doesn\'t have pretrained checkpoints'						)
			def       A_					(						self						):
							pass
			@unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'						)
			def       A_					(						self						):
							pass
			@unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'						)
			def       A_					(						self						):
							pass






			def       A_					(						self						):
							_lowerCamelCase,				_lowerCamelCase  :    Optional[int]					=					self.model_tester.prepare_config_and_inputs_for_common()

							def set_nan_tensor_to_zero(lowercase						):
											_lowerCamelCase  :    List[Any]					=					0
											return t

							def check_equivalence(lowercase						,   lowercase						,   lowercase						,   lowercase={}						):
											with torch.no_grad():
															_lowerCamelCase  :    Optional[Any]					=					model(**lowercase						,   return_dict=lowercase						,   **lowercase						)
															_lowerCamelCase  :    Union[str, Any]					=					model(**lowercase						,   return_dict=lowercase						,   **lowercase						).to_tuple()

															def recursive_check(lowercase						,   lowercase						):
																			if isinstance(lowercase						,   (List, Tuple)						):
																							for tuple_iterable_value, dict_iterable_value in zip(lowercase						,   lowercase						):
																											recursive_check(lowercase						,   lowercase						)
																			elif isinstance(lowercase						,   lowercase						):
																							for tuple_iterable_value, dict_iterable_value in zip(
																							    tuple_object.values()						,   dict_object.values()						):
																											recursive_check(lowercase						,   lowercase						)
																			elif tuple_object is None:
																							return
																			else:
																							self.assertTrue(
																							    torch.allclose(
																							        set_nan_tensor_to_zero(lowercase						)						,   set_nan_tensor_to_zero(lowercase						)						,   atol=1E-5						)						,   msg=(
																							        'Tuple and dict output are not equal. Difference:'
																							        F''' {torch.max(torch.abs(tuple_object - dict_object						)						)}. Tuple has `nan`:'''
																							        F''' {torch.isnan(lowercase						).any()} and `inf`: {torch.isinf(lowercase						)}. Dict has'''
																							        F''' `nan`: {torch.isnan(lowercase						).any()} and `inf`: {torch.isinf(lowercase						)}.'''
																							    )						,   )

															recursive_check(lowercase						,   lowercase						)

							for model_class in self.all_model_classes:
											_lowerCamelCase  :    str					=					model_class(lowercase						)
											model.to(lowercase						)
											model.eval()

											_lowerCamelCase  :    int					=					self._prepare_for_class(lowercase						,   lowercase						)
											_lowerCamelCase  :    Tuple					=					self._prepare_for_class(lowercase						,   lowercase						)
											check_equivalence(lowercase						,   lowercase						,   lowercase						)

											_lowerCamelCase  :    List[Any]					=					self._prepare_for_class(lowercase						,   lowercase						,   return_labels=lowercase						)
											_lowerCamelCase  :    Optional[int]					=					self._prepare_for_class(lowercase						,   lowercase						,   return_labels=lowercase						)
											check_equivalence(lowercase						,   lowercase						,   lowercase						)

											_lowerCamelCase  :    Union[str, Any]					=					self._prepare_for_class(lowercase						,   lowercase						)
											_lowerCamelCase  :    Optional[Any]					=					self._prepare_for_class(lowercase						,   lowercase						)
											check_equivalence(lowercase						,   lowercase						,   lowercase						,   {'output_hidden_states': True}						)

											_lowerCamelCase  :    Dict					=					self._prepare_for_class(lowercase						,   lowercase						,   return_labels=lowercase						)
											_lowerCamelCase  :    str					=					self._prepare_for_class(lowercase						,   lowercase						,   return_labels=lowercase						)
											check_equivalence(lowercase						,   lowercase						,   lowercase						,   {'output_hidden_states': True}						)






@require_torch
class lowerCAmelCase__			(  unittest.TestCase,			lowercase		):






			'''simple docstring'''



			lowerCamelCase__   =    (MaskFormerSwinBackbone,) if is_torch_available() else ()
			lowerCamelCase__   =    MaskFormerSwinConfig
			def       A_					(						self						):
							_lowerCamelCase  :    Dict					=					MaskFormerSwinModelTester(self						)






			def       A_					(						self						):
							_lowerCamelCase,				_lowerCamelCase  :    Any					=					self.model_tester.prepare_config_and_inputs_for_common()
							_lowerCamelCase  :    List[Any]					=					inputs_dict['pixel_values'].shape[0]

							for backbone_class in self.all_model_classes:
											_lowerCamelCase  :    Tuple					=					backbone_class(lowercase						)
											backbone.to(lowercase						)
											backbone.eval()

											_lowerCamelCase  :    List[Any]					=					backbone(**lowercase						)

											# Test default outputs and verify feature maps
											self.assertIsInstance(outputs.feature_maps						,   lowercase						)
											self.assertTrue(len(outputs.feature_maps						) == len(backbone.channels						)						)
											for feature_map, n_channels in zip(outputs.feature_maps						,   backbone.channels						):
															self.assertTrue(feature_map.shape[:2]						,   (batch_size, n_channels)						)
											self.assertIsNone(outputs.hidden_states						)
											self.assertIsNone(outputs.attentions						)

											# Test output_hidden_states=True
											_lowerCamelCase  :    Dict					=					backbone(**lowercase						,   output_hidden_states=lowercase						)
											self.assertIsNotNone(outputs.hidden_states						)
											self.assertTrue(len(outputs.hidden_states						)						,   len(backbone.stage_names						)						)
											# We skip the stem layer
											for hidden_states, n_channels in zip(outputs.hidden_states[1:]						,   backbone.channels						):
															for hidden_state in hidden_states:
																			# Hidden states are in the format (batch_size, (height * width), n_channels)
																			_lowerCamelCase,				_lowerCamelCase,				_lowerCamelCase  :    Dict					=					hidden_state.shape
																			self.assertTrue((h_batch_size, h_n_channels)						,   (batch_size, n_channels)						)

            # Test output_attentions=True
											if self.has_attentions:
															_lowerCamelCase  :    Dict					=					backbone(**lowercase						,   output_attentions=lowercase						)
															self.assertIsNotNone(outputs.attentions						)





"""simple docstring"""






import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase__  		=		logging.get_logger(__name__)

lowercase__  		=		{
    """asapp/sew-d-tiny-100k""": """https://huggingface.co/asapp/sew-d-tiny-100k/resolve/main/config.json""",
    # See all SEW-D models at https://huggingface.co/models?filter=sew-d
}






class lowerCAmelCase__			(  lowercase		):






			'''simple docstring'''



			lowerCamelCase__   =    """sew-d"""
			def __init__(						self						,   lowercase=32						,   lowercase=768						,   lowercase=12						,   lowercase=12						,   lowercase=3072						,   lowercase=2						,   lowercase=512						,   lowercase=256						,   lowercase=True						,   lowercase=True						,   lowercase=("p2c", "c2p")						,   lowercase="layer_norm"						,   lowercase="gelu_python"						,   lowercase=0.1						,   lowercase=0.1						,   lowercase=0.1						,   lowercase=0.0						,   lowercase=0.1						,   lowercase=0.02						,   lowercase=1E-7						,   lowercase=1E-5						,   lowercase="group"						,   lowercase="gelu"						,   lowercase=(64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512)						,   lowercase=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)						,   lowercase=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1)						,   lowercase=False						,   lowercase=128						,   lowercase=16						,   lowercase=True						,   lowercase=0.05						,   lowercase=10						,   lowercase=2						,   lowercase=0.0						,   lowercase=10						,   lowercase=0						,   lowercase="mean"						,   lowercase=False						,   lowercase=False						,   lowercase=256						,   lowercase=0						,   lowercase=1						,   lowercase=2						,   **lowercase						,   ):
							super().__init__(**lowercase						,   pad_token_id=lowercase						,   bos_token_id=lowercase						,   eos_token_id=lowercase						)
							_lowerCamelCase  :    List[str]					=					hidden_size
							_lowerCamelCase  :    int					=					feat_extract_norm
							_lowerCamelCase  :    Optional[Any]					=					feat_extract_activation
							_lowerCamelCase  :    Optional[Any]					=					list(lowercase						)
							_lowerCamelCase  :    Union[str, Any]					=					list(lowercase						)
							_lowerCamelCase  :    Optional[Any]					=					list(lowercase						)
							_lowerCamelCase  :    List[str]					=					conv_bias
							_lowerCamelCase  :    str					=					num_conv_pos_embeddings
							_lowerCamelCase  :    Optional[Any]					=					num_conv_pos_embedding_groups
							_lowerCamelCase  :    Tuple					=					len(self.conv_dim						)
							_lowerCamelCase  :    Optional[int]					=					num_hidden_layers
							_lowerCamelCase  :    List[str]					=					intermediate_size
							_lowerCamelCase  :    Dict					=					squeeze_factor
							_lowerCamelCase  :    Any					=					max_position_embeddings
							_lowerCamelCase  :    List[str]					=					position_buckets
							_lowerCamelCase  :    Dict					=					share_att_key
							_lowerCamelCase  :    List[str]					=					relative_attention
							_lowerCamelCase  :    Optional[Any]					=					norm_rel_ebd
							_lowerCamelCase  :    List[Any]					=					list(lowercase						)
							_lowerCamelCase  :    List[Any]					=					hidden_act
							_lowerCamelCase  :    Optional[Any]					=					num_attention_heads
							_lowerCamelCase  :    Optional[int]					=					hidden_dropout
							_lowerCamelCase  :    Optional[int]					=					attention_dropout
							_lowerCamelCase  :    Any					=					activation_dropout
							_lowerCamelCase  :    Tuple					=					feat_proj_dropout
							_lowerCamelCase  :    Any					=					final_dropout
							_lowerCamelCase  :    str					=					layer_norm_eps
							_lowerCamelCase  :    Tuple					=					feature_layer_norm_eps
							_lowerCamelCase  :    Any					=					initializer_range
							_lowerCamelCase  :    Dict					=					vocab_size

							if (
							    (len(self.conv_stride						) != self.num_feat_extract_layers)
							    or (len(self.conv_kernel						) != self.num_feat_extract_layers)
							    or (len(self.conv_dim						) != self.num_feat_extract_layers)
							):
											raise ValueError(
											    'Configuration for convolutional layers is incorrect.'
											    'It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,'
											    F'''but is `len(config.conv_dim) = {len(self.conv_dim						)}`, `len(config.conv_stride)'''
											    F'''= {len(self.conv_stride						)}`, `len(config.conv_kernel) = {len(self.conv_kernel						)}`.'''						)

							# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
							_lowerCamelCase  :    Dict					=					apply_spec_augment
							_lowerCamelCase  :    int					=					mask_time_prob
							_lowerCamelCase  :    Union[str, Any]					=					mask_time_length
							_lowerCamelCase  :    Optional[Any]					=					mask_time_min_masks
							_lowerCamelCase  :    List[Any]					=					mask_feature_prob
							_lowerCamelCase  :    Union[str, Any]					=					mask_feature_length
							_lowerCamelCase  :    List[Any]					=					mask_feature_min_masks

							# ctc loss
							_lowerCamelCase  :    List[str]					=					ctc_loss_reduction
							_lowerCamelCase  :    List[str]					=					ctc_zero_infinity

							# sequence classification
							_lowerCamelCase  :    Dict					=					use_weighted_layer_sum
							_lowerCamelCase  :    List[Any]					=					classifier_proj_size






			@property
			def       A_					(						self						):
							return functools.reduce(operator.mul						,   self.conv_stride						,   1						)