



import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

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


if is_torch_available():
							import torch

							from transformers import EsmForMaskedLM, EsmForSequenceClassification, EsmForTokenClassification, EsmModel
							from transformers.models.esm.modeling_esm import (
							    ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
							    EsmEmbeddings,
							    create_position_ids_from_input_ids,
							)


class   lowercase      :




							def __init__(  self				:   Optional[int]		,							_UpperCamelCase				:   Optional[int]		,							_UpperCamelCase				:   Optional[Any]=13		,							_UpperCamelCase				:   Tuple=7		,							_UpperCamelCase				:   Optional[Any]=False		,							_UpperCamelCase				:   Optional[int]=True		,							_UpperCamelCase				:   Dict=False		,							_UpperCamelCase				:   List[str]=True		,							_UpperCamelCase				:   List[str]=33		,							_UpperCamelCase				:   Dict=32		,							_UpperCamelCase				:   int=5		,							_UpperCamelCase				:   List[str]=4		,							_UpperCamelCase				:   Any=37		,							_UpperCamelCase				:   Dict="gelu"		,							_UpperCamelCase				:   List[Any]=0.1		,							_UpperCamelCase				:   str=0.1		,							_UpperCamelCase				:   List[str]=512		,							_UpperCamelCase				:   int=16		,							_UpperCamelCase				:   Tuple=2		,							_UpperCamelCase				:   int=0.0_2		,							_UpperCamelCase				:   Union[str, Any]=3		,							_UpperCamelCase				:   List[Any]=4		,							_UpperCamelCase				:   Optional[int]=None		,							)   ->			Union[str, Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    parent
												SCREAMING_SNAKE_CASE           =    batch_size
												SCREAMING_SNAKE_CASE           =    seq_length
												SCREAMING_SNAKE_CASE           =    is_training
												SCREAMING_SNAKE_CASE           =    use_input_mask
												SCREAMING_SNAKE_CASE           =    use_token_type_ids
												SCREAMING_SNAKE_CASE           =    use_labels
												SCREAMING_SNAKE_CASE           =    vocab_size
												SCREAMING_SNAKE_CASE           =    hidden_size
												SCREAMING_SNAKE_CASE           =    num_hidden_layers
												SCREAMING_SNAKE_CASE           =    num_attention_heads
												SCREAMING_SNAKE_CASE           =    intermediate_size
												SCREAMING_SNAKE_CASE           =    hidden_act
												SCREAMING_SNAKE_CASE           =    hidden_dropout_prob
												SCREAMING_SNAKE_CASE           =    attention_probs_dropout_prob
												SCREAMING_SNAKE_CASE           =    max_position_embeddings
												SCREAMING_SNAKE_CASE           =    type_vocab_size
												SCREAMING_SNAKE_CASE           =    type_sequence_label_size
												SCREAMING_SNAKE_CASE           =    initializer_range
												SCREAMING_SNAKE_CASE           =    num_labels
												SCREAMING_SNAKE_CASE           =    num_choices
												SCREAMING_SNAKE_CASE           =    scope




							def 		__snake_case(  self				:   Optional[int] )   ->			Union[str, Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    ids_tensor([self.batch_size, self.seq_length]		,							self.vocab_size )

												SCREAMING_SNAKE_CASE           =    None
												if self.use_input_mask:
																	SCREAMING_SNAKE_CASE           =    random_attention_mask([self.batch_size, self.seq_length] )

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

												SCREAMING_SNAKE_CASE           =    self.get_config()

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




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



												'''simple docstring'''

												return EsmConfig(
												    vocab_size=self.vocab_size		,							hidden_size=self.hidden_size		,							pad_token_id=1		,							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		,							initializer_range=self.initializer_range		,							)




							def 		__snake_case(  self				:   Optional[Any]		,							_UpperCamelCase				:   Optional[int]		,							_UpperCamelCase				:   List[str]		,							_UpperCamelCase				:   Any		,							_UpperCamelCase				:   int		,							_UpperCamelCase				:   Tuple		,							_UpperCamelCase				:   Any )   ->			List[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    EsmModel(config=_UpperCamelCase )
												model.to(_UpperCamelCase )
												model.eval()
												SCREAMING_SNAKE_CASE           =    model(_UpperCamelCase		,							attention_mask=_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    model(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    model(_UpperCamelCase )

												self.parent.assertEqual(result.last_hidden_state.shape		,							(self.batch_size, self.seq_length, self.hidden_size) )
												self.parent.assertEqual(result.pooler_output.shape		,							(self.batch_size, self.hidden_size) )




							def 		__snake_case(  self				:   Optional[Any]		,							_UpperCamelCase				:   Any		,							_UpperCamelCase				:   int		,							_UpperCamelCase				:   Optional[int]		,							_UpperCamelCase				:   str		,							_UpperCamelCase				:   Optional[int]		,							_UpperCamelCase				:   Union[str, Any] )   ->			Union[str, Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    EsmForMaskedLM(config=_UpperCamelCase )
												model.to(_UpperCamelCase )
												model.eval()
												SCREAMING_SNAKE_CASE           =    model(_UpperCamelCase		,							attention_mask=_UpperCamelCase		,							labels=_UpperCamelCase )
												self.parent.assertEqual(result.logits.shape		,							(self.batch_size, self.seq_length, self.vocab_size) )




							def 		__snake_case(  self				:   Tuple		,							_UpperCamelCase				:   Optional[Any]		,							_UpperCamelCase				:   int		,							_UpperCamelCase				:   Tuple		,							_UpperCamelCase				:   Dict		,							_UpperCamelCase				:   List[Any]		,							_UpperCamelCase				:   Union[str, Any] )   ->			Dict:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.num_labels
												SCREAMING_SNAKE_CASE           =    EsmForTokenClassification(config=_UpperCamelCase )
												model.to(_UpperCamelCase )
												model.eval()
												SCREAMING_SNAKE_CASE           =    model(_UpperCamelCase		,							attention_mask=_UpperCamelCase		,							labels=_UpperCamelCase )
												self.parent.assertEqual(result.logits.shape		,							(self.batch_size, self.seq_length, self.num_labels) )





							def 		__snake_case(  self				:   Dict )   ->			Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.prepare_config_and_inputs()
												(
												    (
												    SCREAMING_SNAKE_CASE				
												)     ,				(
												    SCREAMING_SNAKE_CASE				
												)     ,				(
												    SCREAMING_SNAKE_CASE				
												)     ,				(
												    SCREAMING_SNAKE_CASE				
												)     ,				(
												    SCREAMING_SNAKE_CASE				
												)     ,				(
												    SCREAMING_SNAKE_CASE				
												)     ,								
												)           =    config_and_inputs
												SCREAMING_SNAKE_CASE           =    {"input_ids": input_ids, "attention_mask": input_mask}
												return config, inputs_dict



@require_torch
class   lowercase      (       a			,    a			,    unittest.TestCase       ):
							lowercase__  :    Dict									=							False

							lowercase__  :    Optional[int]									=							(
							    (
							        EsmForMaskedLM,
							        EsmModel,
							        EsmForSequenceClassification,
							        EsmForTokenClassification,
							    )
							    if is_torch_available()
							    else ()
							)
							lowercase__  :    Any									=							()
							lowercase__  :    List[Any]									=							(
							    {
							        """feature-extraction""": EsmModel,
							        """fill-mask""": EsmForMaskedLM,
							        """text-classification""": EsmForSequenceClassification,
							        """token-classification""": EsmForTokenClassification,
							        """zero-shot""": EsmForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							lowercase__  :    List[str]									=							True




							def 		__snake_case(  self				:   List[Any] )   ->			Tuple:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    EsmModelTester(self )
												SCREAMING_SNAKE_CASE           =    ConfigTester(self		,							config_class=_UpperCamelCase		,							hidden_size=37 )




							def 		__snake_case(  self				:   Optional[int] )   ->			Dict:



												'''simple docstring'''

												self.config_tester.run_common_tests()




							def 		__snake_case(  self				:   Any )   ->			str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_UpperCamelCase )




							def 		__snake_case(  self				:   List[Any] )   ->			Optional[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()
												for type in ["absolute", "relative_key", "relative_key_query"]:
																	SCREAMING_SNAKE_CASE           =    type
																	self.model_tester.create_and_check_model(*_UpperCamelCase )




							def 		__snake_case(  self				:   Tuple )   ->			Dict:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*_UpperCamelCase )




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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase )




							@slow
							def 		__snake_case(  self				:   str )   ->			Any:



												'''simple docstring'''

												for model_name in ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	SCREAMING_SNAKE_CASE           =    EsmModel.from_pretrained(_UpperCamelCase )
																	self.assertIsNotNone(_UpperCamelCase )




							def 		__snake_case(  self				:   Optional[Any] )   ->			List[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()[0]
												SCREAMING_SNAKE_CASE           =    EsmEmbeddings(config=_UpperCamelCase )

												SCREAMING_SNAKE_CASE           =    torch.as_tensor([[12, 31, 13, model.padding_idx]] )
												SCREAMING_SNAKE_CASE           =    torch.as_tensor(
												    [
												        [
												            0 + model.padding_idx + 1,
												            1 + model.padding_idx + 1,
												            2 + model.padding_idx + 1,
												            model.padding_idx,
												        ]
												    ] )
												SCREAMING_SNAKE_CASE           =    create_position_ids_from_input_ids(_UpperCamelCase		,							model.padding_idx )
												self.assertEqual(position_ids.shape		,							expected_positions.shape )
												self.assertTrue(torch.all(torch.eq(_UpperCamelCase		,							_UpperCamelCase ) ) )




							def 		__snake_case(  self				:   int )   ->			List[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE           =    self.model_tester.prepare_config_and_inputs()[0]
												SCREAMING_SNAKE_CASE           =    EsmEmbeddings(config=_UpperCamelCase )

												SCREAMING_SNAKE_CASE           =    torch.empty(2		,							4		,							30 )
												SCREAMING_SNAKE_CASE           =    [
												    0 + embeddings.padding_idx + 1,
												    1 + embeddings.padding_idx + 1,
												    2 + embeddings.padding_idx + 1,
												    3 + embeddings.padding_idx + 1,
												]
												SCREAMING_SNAKE_CASE           =    torch.as_tensor([expected_single_positions, expected_single_positions] )
												SCREAMING_SNAKE_CASE           =    embeddings.create_position_ids_from_inputs_embeds(_UpperCamelCase )
												self.assertEqual(position_ids.shape		,							expected_positions.shape )
												self.assertTrue(torch.all(torch.eq(_UpperCamelCase		,							_UpperCamelCase ) ) )




							@unittest.skip("Esm does not support embedding resizing" )
							def 		__snake_case(  self				:   int )   ->			Tuple:



												'''simple docstring'''

												pass




							@unittest.skip("Esm does not support embedding resizing" )
							def 		__snake_case(  self				:   List[str] )   ->			int:



												'''simple docstring'''

												pass





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



												'''simple docstring'''

												pass



@require_torch
class   lowercase      (       a       ):




							@slow
							def 		__snake_case(  self				:   Union[str, Any] )   ->			Optional[int]:



												'''simple docstring'''

												with torch.no_grad():
																	SCREAMING_SNAKE_CASE           =    EsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D" )
																	model.eval()
																	SCREAMING_SNAKE_CASE           =    torch.tensor([[0, 1, 2, 3, 4, 5]] )
																	SCREAMING_SNAKE_CASE           =    model(_UpperCamelCase )[0]

																	SCREAMING_SNAKE_CASE           =    33

																	SCREAMING_SNAKE_CASE           =    torch.Size((1, 6, vocab_size) )
																	self.assertEqual(output.shape		,							_UpperCamelCase )

																	SCREAMING_SNAKE_CASE           =    torch.tensor(
																	    [[[8.9_2_1_5, -10.5_898, -6.4_6_7_1], [-6.3_9_6_7, -13.9_114, -1.1_2_1_2], [-7.7_8_1_2, -13.9_516, -3.7_4_0_6]]] )
																	self.assertTrue(torch.allclose(output[:, :3, :3]		,							_UpperCamelCase		,							atol=1e-4 ) )





							@slow
							def 		__snake_case(  self				:   List[str] )   ->			List[Any]:



												'''simple docstring'''

												with torch.no_grad():
																	SCREAMING_SNAKE_CASE           =    EsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D" )
																	model.eval()

																	SCREAMING_SNAKE_CASE           =    torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]] )
																	SCREAMING_SNAKE_CASE           =    model(_UpperCamelCase )[0]
																	# compare the actual values for a slice.
																	SCREAMING_SNAKE_CASE           =    torch.tensor(
																	    [[[0.1_4_4_4, 0.5_4_1_3, 0.3_2_4_8], [0.3_0_3_4, 0.0_0_5_3, 0.3_1_0_8], [0.3_2_2_8, -0.2_4_9_9, 0.3_4_1_5]]] )
																	self.assertTrue(torch.allclose(output[:, :3, :3]		,							_UpperCamelCase		,							atol=1e-4 ) )





import functools
import operator

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


_lowerCamelCase   :				int     			=						logging.get_logger(__name__)

_lowerCamelCase   :				Union[str, Any]     			=						{
    '''microsoft/unispeech-sat-base-100h-libri-ft''': (
        '''https://huggingface.co/microsoft/unispeech-sat-base-100h-libri-ft/resolve/main/config.json'''
    ),
    # See all UniSpeechSat models at https://huggingface.co/models?filter=unispeech_sat
}


class   lowercase      (       a       ):
							lowercase__  :    Tuple									=							"""unispeech-sat"""




							def __init__(  self				:   str		,							_UpperCamelCase				:   Tuple=32		,							_UpperCamelCase				:   Union[str, Any]=768		,							_UpperCamelCase				:   Tuple=12		,							_UpperCamelCase				:   List[str]=12		,							_UpperCamelCase				:   Tuple=3_072		,							_UpperCamelCase				:   List[str]="gelu"		,							_UpperCamelCase				:   Tuple=0.1		,							_UpperCamelCase				:   Any=0.1		,							_UpperCamelCase				:   Union[str, Any]=0.1		,							_UpperCamelCase				:   Dict=0.0		,							_UpperCamelCase				:   Tuple=0.0		,							_UpperCamelCase				:   Tuple=0.1		,							_UpperCamelCase				:   Optional[Any]=0.1		,							_UpperCamelCase				:   Tuple=0.0_2		,							_UpperCamelCase				:   Optional[int]=1e-5		,							_UpperCamelCase				:   Union[str, Any]="group"		,							_UpperCamelCase				:   Optional[int]="gelu"		,							_UpperCamelCase				:   Tuple=(512, 512, 512, 512, 512, 512, 512)		,							_UpperCamelCase				:   List[str]=(5, 2, 2, 2, 2, 2, 2)		,							_UpperCamelCase				:   Optional[int]=(10, 3, 3, 3, 3, 2, 2)		,							_UpperCamelCase				:   Optional[int]=False		,							_UpperCamelCase				:   Dict=128		,							_UpperCamelCase				:   Optional[int]=16		,							_UpperCamelCase				:   Tuple=False		,							_UpperCamelCase				:   Union[str, Any]=True		,							_UpperCamelCase				:   Optional[Any]=0.0_5		,							_UpperCamelCase				:   Union[str, Any]=10		,							_UpperCamelCase				:   Union[str, Any]=2		,							_UpperCamelCase				:   str=0.0		,							_UpperCamelCase				:   List[Any]=10		,							_UpperCamelCase				:   Optional[int]=0		,							_UpperCamelCase				:   Any=320		,							_UpperCamelCase				:   List[Any]=2		,							_UpperCamelCase				:   str=0.1		,							_UpperCamelCase				:   str=100		,							_UpperCamelCase				:   int=256		,							_UpperCamelCase				:   Optional[Any]=256		,							_UpperCamelCase				:   List[Any]=0.1		,							_UpperCamelCase				:   str="mean"		,							_UpperCamelCase				:   int=False		,							_UpperCamelCase				:   Optional[Any]=False		,							_UpperCamelCase				:   Any=256		,							_UpperCamelCase				:   str=(512, 512, 512, 512, 1_500)		,							_UpperCamelCase				:   List[Any]=(5, 3, 3, 1, 1)		,							_UpperCamelCase				:   Union[str, Any]=(1, 2, 3, 1, 1)		,							_UpperCamelCase				:   Any=512		,							_UpperCamelCase				:   str=0		,							_UpperCamelCase				:   int=1		,							_UpperCamelCase				:   Any=2		,							_UpperCamelCase				:   Optional[Any]=504		,							**_UpperCamelCase				:   str		,							)   ->			int:



												'''simple docstring'''

												super().__init__(**_UpperCamelCase		,							pad_token_id=_UpperCamelCase		,							bos_token_id=_UpperCamelCase		,							eos_token_id=_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    hidden_size
												SCREAMING_SNAKE_CASE           =    feat_extract_norm
												SCREAMING_SNAKE_CASE           =    feat_extract_activation
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    conv_bias
												SCREAMING_SNAKE_CASE           =    num_conv_pos_embeddings
												SCREAMING_SNAKE_CASE           =    num_conv_pos_embedding_groups
												SCREAMING_SNAKE_CASE           =    len(self.conv_dim )
												SCREAMING_SNAKE_CASE           =    num_hidden_layers
												SCREAMING_SNAKE_CASE           =    intermediate_size
												SCREAMING_SNAKE_CASE           =    hidden_act
												SCREAMING_SNAKE_CASE           =    num_attention_heads
												SCREAMING_SNAKE_CASE           =    hidden_dropout
												SCREAMING_SNAKE_CASE           =    attention_dropout
												SCREAMING_SNAKE_CASE           =    activation_dropout
												SCREAMING_SNAKE_CASE           =    feat_proj_dropout
												SCREAMING_SNAKE_CASE           =    final_dropout
												SCREAMING_SNAKE_CASE           =    layerdrop
												SCREAMING_SNAKE_CASE           =    layer_norm_eps
												SCREAMING_SNAKE_CASE           =    initializer_range
												SCREAMING_SNAKE_CASE           =    vocab_size
												SCREAMING_SNAKE_CASE           =    num_clusters
												SCREAMING_SNAKE_CASE           =    do_stable_layer_norm
												SCREAMING_SNAKE_CASE           =    use_weighted_layer_sum

												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)`, but is `len(config.conv_dim) ="
																	    F" {len(self.conv_dim )}`, `len(config.conv_stride) = {len(self.conv_stride )}`,"
																	    F" `len(config.conv_kernel) = {len(self.conv_kernel )}`." )

												# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
												SCREAMING_SNAKE_CASE           =    apply_spec_augment
												SCREAMING_SNAKE_CASE           =    mask_time_prob
												SCREAMING_SNAKE_CASE           =    mask_time_length
												SCREAMING_SNAKE_CASE           =    mask_time_min_masks
												SCREAMING_SNAKE_CASE           =    mask_feature_prob
												SCREAMING_SNAKE_CASE           =    mask_feature_length
												SCREAMING_SNAKE_CASE           =    mask_feature_min_masks

												# parameters for pretraining with codevector quantized representations
												SCREAMING_SNAKE_CASE           =    num_codevectors_per_group
												SCREAMING_SNAKE_CASE           =    num_codevector_groups
												SCREAMING_SNAKE_CASE           =    contrastive_logits_temperature
												SCREAMING_SNAKE_CASE           =    feat_quantizer_dropout
												SCREAMING_SNAKE_CASE           =    num_negatives
												SCREAMING_SNAKE_CASE           =    codevector_dim
												SCREAMING_SNAKE_CASE           =    proj_codevector_dim
												SCREAMING_SNAKE_CASE           =    diversity_loss_weight

												# ctc loss
												SCREAMING_SNAKE_CASE           =    ctc_loss_reduction
												SCREAMING_SNAKE_CASE           =    ctc_zero_infinity

												# SequenceClassification-specific parameter. Feel free to ignore for other classes.
												SCREAMING_SNAKE_CASE           =    classifier_proj_size

												# XVector-specific parameters. Feel free to ignore for other classes.
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    xvector_output_dim





							@property
							def 		__snake_case(  self				:   Tuple )   ->			str:



												'''simple docstring'''

												return functools.reduce(operator.mul		,							self.conv_stride		,							1 )




