





"""simple docstring"""
from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import (
    BackboneOutput,
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import (
    add_code_sample_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    logging,
    replace_return_docstrings,
)
from ...utils.backbone_utils import BackboneMixin
from .configuration_resnet import ResNetConfig


__A       =		logging.get_logger(__name__)

# General docstring
__A       =		'''ResNetConfig'''

# Base docstring
__A       =		'''microsoft/resnet-50'''
__A       =		[1, 2_0_4_8, 7, 7]

# Image classification docstring
__A       =		'''microsoft/resnet-50'''
__A       =		'''tiger cat'''

__A       =		[
    '''microsoft/resnet-50''',
    # See all resnet models at https://huggingface.co/models?filter=resnet
]






class  _SCREAMING_SNAKE_CASE(       nn.Module  ):




       def __init__(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = 3		,SCREAMING_SNAKE_CASE__ = 1		,SCREAMING_SNAKE_CASE__ = "relu"							)      ->				Tuple:





             """simple docstring"""






             super().__init__()
             __SCREAMING_SNAKE_CASE       :int		    =  nn.Convad(
                 __lowerCamelCase		,__lowerCamelCase		,kernel_size=__lowerCamelCase		,stride=__lowerCamelCase		,padding=kernel_size // 2		,bias=__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :int		    =  nn.BatchNormad(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  ACTaFN[activation] if activation is not None else nn.Identity()




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__							)      ->				str:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Tuple		    =  self.convolution(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Dict		    =  self.normalization(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :str		    =  self.activation(__lowerCamelCase							)
             return hidden_state






class  _SCREAMING_SNAKE_CASE(       nn.Module  ):




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





             """simple docstring"""






             super().__init__()
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  ResNetConvLayer(
                 config.num_channels		,config.embedding_size		,kernel_size=7		,stride=2		,activation=config.hidden_act							)
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  nn.MaxPoolad(kernel_size=3		,stride=2		,padding=1							)
             __SCREAMING_SNAKE_CASE       :str		    =  config.num_channels




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





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Dict		    =  pixel_values.shape[1]
             if num_channels != self.num_channels:
                   raise ValueError(
                       '''Make sure that the channel dimension of the pixel values match with the one set in the configuration.'''							)
             __SCREAMING_SNAKE_CASE       :int		    =  self.embedder(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Tuple		    =  self.pooler(__lowerCamelCase							)
             return embedding






class  _SCREAMING_SNAKE_CASE(       nn.Module  ):




       def __init__(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = 2							)      ->				Union[str, Any]:





             """simple docstring"""






             super().__init__()
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  nn.Convad(__lowerCamelCase		,__lowerCamelCase		,kernel_size=1		,stride=__lowerCamelCase		,bias=__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Dict		    =  nn.BatchNormad(__lowerCamelCase							)




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__							)      ->				List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :str		    =  self.convolution(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Dict		    =  self.normalization(__lowerCamelCase							)
             return hidden_state






class  _SCREAMING_SNAKE_CASE(       nn.Module  ):




       def __init__(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = 1		,SCREAMING_SNAKE_CASE__ = "relu"							)      ->				List[Any]:





             """simple docstring"""






             super().__init__()
             __SCREAMING_SNAKE_CASE       :List[str]		    =  in_channels != out_channels or stride != 1
             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  (
                 ResNetShortCut(__lowerCamelCase		,__lowerCamelCase		,stride=__lowerCamelCase							) if should_apply_shortcut else nn.Identity()
             )
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  nn.Sequential(
                 ResNetConvLayer(__lowerCamelCase		,__lowerCamelCase		,stride=__lowerCamelCase							)		,ResNetConvLayer(__lowerCamelCase		,__lowerCamelCase		,activation=__lowerCamelCase							)		,)
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  ACTaFN[activation]




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__							)      ->				List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Tuple		    =  hidden_state
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  self.layer(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  self.shortcut(__lowerCamelCase							)
             hidden_state += residual
             __SCREAMING_SNAKE_CASE       :int		    =  self.activation(__lowerCamelCase							)
             return hidden_state






class  _SCREAMING_SNAKE_CASE(       nn.Module  ):




       def __init__(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = 1		,SCREAMING_SNAKE_CASE__ = "relu"		,SCREAMING_SNAKE_CASE__ = 4							)      ->				List[Any]:





             """simple docstring"""






             super().__init__()
             __SCREAMING_SNAKE_CASE       :str		    =  in_channels != out_channels or stride != 1
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  out_channels // reduction
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  (
                 ResNetShortCut(__lowerCamelCase		,__lowerCamelCase		,stride=__lowerCamelCase							) if should_apply_shortcut else nn.Identity()
             )
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  nn.Sequential(
                 ResNetConvLayer(__lowerCamelCase		,__lowerCamelCase		,kernel_size=1							)		,ResNetConvLayer(__lowerCamelCase		,__lowerCamelCase		,stride=__lowerCamelCase							)		,ResNetConvLayer(__lowerCamelCase		,__lowerCamelCase		,kernel_size=1		,activation=__lowerCamelCase							)		,)
             __SCREAMING_SNAKE_CASE       :str		    =  ACTaFN[activation]




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__							)      ->				Any:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  hidden_state
             __SCREAMING_SNAKE_CASE       :str		    =  self.layer(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Tuple		    =  self.shortcut(__lowerCamelCase							)
             hidden_state += residual
             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  self.activation(__lowerCamelCase							)
             return hidden_state






class  _SCREAMING_SNAKE_CASE(       nn.Module  ):




       def __init__(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = 2		,SCREAMING_SNAKE_CASE__ = 2		,)      ->				Any:





             """simple docstring"""






             super().__init__()

             __SCREAMING_SNAKE_CASE       :Dict		    =  ResNetBottleNeckLayer if config.layer_type == """bottleneck""" else ResNetBasicLayer

             __SCREAMING_SNAKE_CASE       :str		    =  nn.Sequential(
                 # downsampling is done in the first layer with stride of 2
                 layer(__lowerCamelCase		,__lowerCamelCase		,stride=__lowerCamelCase		,activation=config.hidden_act							)		,*[layer(__lowerCamelCase		,__lowerCamelCase		,activation=config.hidden_act							) for _ in range(depth - 1							)]		,)




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





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Dict		    =  input
             for layer in self.layers:
                   __SCREAMING_SNAKE_CASE       :Optional[int]		    =  layer(__lowerCamelCase							)
             return hidden_state






class  _SCREAMING_SNAKE_CASE(       nn.Module  ):




       def __init__(						self		,SCREAMING_SNAKE_CASE__							)      ->				Any:





             """simple docstring"""






             super().__init__()
             __SCREAMING_SNAKE_CASE       :List[str]		    =  nn.ModuleList([]							)
             # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
             self.stages.append(
                 ResNetStage(
                     __lowerCamelCase		,config.embedding_size		,config.hidden_sizes[0]		,stride=2 if config.downsample_in_first_stage else 1		,depth=config.depths[0]		,)							)
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  zip(config.hidden_sizes		,config.hidden_sizes[1:]							)
             for (in_channels, out_channels), depth in zip(__lowerCamelCase		,config.depths[1:]							):
                   self.stages.append(ResNetStage(__lowerCamelCase		,__lowerCamelCase		,__lowerCamelCase		,depth=__lowerCamelCase							)							)




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = False		,SCREAMING_SNAKE_CASE__ = True							)      ->				Union[str, Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Dict		    =  () if output_hidden_states else None

             for stage_module in self.stages:
                   if output_hidden_states:
                         __SCREAMING_SNAKE_CASE       :Any		    =  hidden_states + (hidden_state,)

                   __SCREAMING_SNAKE_CASE       :Dict		    =  stage_module(__lowerCamelCase							)

             if output_hidden_states:
                   __SCREAMING_SNAKE_CASE       :Any		    =  hidden_states + (hidden_state,)

             if not return_dict:
                   return tuple(v for v in [hidden_state, hidden_states] if v is not None							)

             return BaseModelOutputWithNoAttention(
                 last_hidden_state=__lowerCamelCase		,hidden_states=__lowerCamelCase		,)






class  _SCREAMING_SNAKE_CASE(       _a  ):
       SCREAMING_SNAKE_CASE_       :				Any     						=  ResNetConfig
       SCREAMING_SNAKE_CASE_       :				Dict     						=  """resnet"""
       SCREAMING_SNAKE_CASE_       :				str     						=  """pixel_values"""
       SCREAMING_SNAKE_CASE_       :				Tuple     						=  True




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





             """simple docstring"""






             if isinstance(__lowerCamelCase		,nn.Convad							):
                   nn.init.kaiming_normal_(module.weight		,mode='''fan_out'''		,nonlinearity='''relu'''							)
             elif isinstance(__lowerCamelCase		,(nn.BatchNormad, nn.GroupNorm)							):
                   nn.init.constant_(module.weight		,1							)
                   nn.init.constant_(module.bias		,0							)




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=False							)      ->				Optional[Any]:





             """simple docstring"""






             if isinstance(__lowerCamelCase		,__lowerCamelCase							):
                   __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  value




__A       =		R'''
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
'''

__A       =		R'''
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__call__`] for details.

        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
'''






@add_start_docstrings(
    '''The bare ResNet model outputting raw features without any specific head on top.'''   ,     _a   ,     )
class  _SCREAMING_SNAKE_CASE(       _a  ):




       def __init__(						self		,SCREAMING_SNAKE_CASE__							)      ->				Optional[int]:





             """simple docstring"""






             super().__init__(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Tuple		    =  config
             __SCREAMING_SNAKE_CASE       :str		    =  ResNetEmbeddings(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Dict		    =  ResNetEncoder(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Dict		    =  nn.AdaptiveAvgPoolad((1, 1)							)
             # Initialize weights and apply final processing
             self.post_init()




       @add_start_docstrings_to_model_forward(__lowerCamelCase							)
       @add_code_sample_docstrings(
           checkpoint=_CHECKPOINT_FOR_DOC		,output_type=__lowerCamelCase		,config_class=_CONFIG_FOR_DOC		,modality='''vision'''		,expected_output=_EXPECTED_OUTPUT_SHAPE		,)
       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None							)      ->				str:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  (
                 output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
             )
             __SCREAMING_SNAKE_CASE       :Dict		    =  return_dict if return_dict is not None else self.config.use_return_dict

             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  self.embedder(__lowerCamelCase							)

             __SCREAMING_SNAKE_CASE       :Tuple		    =  self.encoder(
                 __lowerCamelCase		,output_hidden_states=__lowerCamelCase		,return_dict=__lowerCamelCase							)

             __SCREAMING_SNAKE_CASE       :Dict		    =  encoder_outputs[0]

             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  self.pooler(__lowerCamelCase							)

             if not return_dict:
                   return (last_hidden_state, pooled_output) + encoder_outputs[1:]

             return BaseModelOutputWithPoolingAndNoAttention(
                 last_hidden_state=__lowerCamelCase		,pooler_output=__lowerCamelCase		,hidden_states=encoder_outputs.hidden_states		,)






@add_start_docstrings(
    '''
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    '''   ,     _a   ,     )
class  _SCREAMING_SNAKE_CASE(       _a  ):




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





             """simple docstring"""






             super().__init__(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  config.num_labels
             __SCREAMING_SNAKE_CASE       :int		    =  ResNetModel(__lowerCamelCase							)
             # classification head
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  nn.Sequential(
                 nn.Flatten()		,nn.Linear(config.hidden_sizes[-1]		,config.num_labels							) if config.num_labels > 0 else nn.Identity()		,)
             # initialize weights and apply final processing
             self.post_init()




       @add_start_docstrings_to_model_forward(__lowerCamelCase							)
       @add_code_sample_docstrings(
           checkpoint=_IMAGE_CLASS_CHECKPOINT		,output_type=__lowerCamelCase		,config_class=_CONFIG_FOR_DOC		,expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT		,)
       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None		,)      ->				List[str]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :str		    =  return_dict if return_dict is not None else self.config.use_return_dict

             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  self.resnet(__lowerCamelCase		,output_hidden_states=__lowerCamelCase		,return_dict=__lowerCamelCase							)

             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  outputs.pooler_output if return_dict else outputs[1]

             __SCREAMING_SNAKE_CASE       :Tuple		    =  self.classifier(__lowerCamelCase							)

             __SCREAMING_SNAKE_CASE       :List[Any]		    =  None

             if labels is not None:
                   if self.config.problem_type is None:
                         if self.num_labels == 1:
                               __SCREAMING_SNAKE_CASE       :List[str]		    =  """regression"""
                         elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
                               __SCREAMING_SNAKE_CASE       :List[str]		    =  """single_label_classification"""
                         else:
                               __SCREAMING_SNAKE_CASE       :Tuple		    =  """multi_label_classification"""
                   if self.config.problem_type == "regression":
                         __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  MSELoss()
                         if self.num_labels == 1:
                               __SCREAMING_SNAKE_CASE       :Dict		    =  loss_fct(logits.squeeze()		,labels.squeeze()							)
                         else:
                               __SCREAMING_SNAKE_CASE       :Optional[int]		    =  loss_fct(__lowerCamelCase		,__lowerCamelCase							)
                   elif self.config.problem_type == "single_label_classification":
                         __SCREAMING_SNAKE_CASE       :Any		    =  CrossEntropyLoss()
                         __SCREAMING_SNAKE_CASE       :List[str]		    =  loss_fct(logits.view(-1		,self.num_labels							)		,labels.view(-1							)							)
                   elif self.config.problem_type == "multi_label_classification":
                         __SCREAMING_SNAKE_CASE       :Dict		    =  BCEWithLogitsLoss()
                         __SCREAMING_SNAKE_CASE       :Any		    =  loss_fct(__lowerCamelCase		,__lowerCamelCase							)

             if not return_dict:
                   __SCREAMING_SNAKE_CASE       :Tuple		    =  (logits,) + outputs[2:]
                   return (loss,) + output if loss is not None else output

             return ImageClassifierOutputWithNoAttention(loss=__lowerCamelCase		,logits=__lowerCamelCase		,hidden_states=outputs.hidden_states							)






@add_start_docstrings(
    '''
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    '''   ,     _a   ,     )
class  _SCREAMING_SNAKE_CASE(       _a   ,     _a  ):




       def __init__(						self		,SCREAMING_SNAKE_CASE__							)      ->				List[str]:





             """simple docstring"""






             super().__init__(__lowerCamelCase							)
             super()._init_backbone(__lowerCamelCase							)

             __SCREAMING_SNAKE_CASE       :int		    =  [config.embedding_size] + config.hidden_sizes
             __SCREAMING_SNAKE_CASE       :Any		    =  ResNetEmbeddings(__lowerCamelCase							)
             __SCREAMING_SNAKE_CASE       :Dict		    =  ResNetEncoder(__lowerCamelCase							)

             # initialize weights and apply final processing
             self.post_init()




       @add_start_docstrings_to_model_forward(__lowerCamelCase							)
       @replace_return_docstrings(output_type=__lowerCamelCase		,config_class=_CONFIG_FOR_DOC							)
       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__ = None		,SCREAMING_SNAKE_CASE__ = None							)      ->				List[str]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Dict		    =  return_dict if return_dict is not None else self.config.use_return_dict
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  (
                 output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
             )

             __SCREAMING_SNAKE_CASE       :str		    =  self.embedder(__lowerCamelCase							)

             __SCREAMING_SNAKE_CASE       :List[str]		    =  self.encoder(__lowerCamelCase		,output_hidden_states=__lowerCamelCase		,return_dict=__lowerCamelCase							)

             __SCREAMING_SNAKE_CASE       :List[str]		    =  outputs.hidden_states

             __SCREAMING_SNAKE_CASE       :int		    =  ()
             for idx, stage in enumerate(self.stage_names							):
                   if stage in self.out_features:
                         feature_maps += (hidden_states[idx],)

             if not return_dict:
                   __SCREAMING_SNAKE_CASE       :Dict		    =  (feature_maps,)
                   if output_hidden_states:
                         output += (outputs.hidden_states,)
                   return output

             return BackboneOutput(
                 feature_maps=__lowerCamelCase		,hidden_states=outputs.hidden_states if output_hidden_states else None		,attentions=__lowerCamelCase		,)






"""simple docstring"""
import math
import random



def 					__lowerCamelCase       (							a_					:		float			,       a_					:		bool = False							)      ->				float:
      if deriv:
            return value * (1 - value)
      return 1 / (1 + math.exp(-value							))


# Initial Value
lowerCamelCase_       =		0.02



def 					__lowerCamelCase       (							a_					:		int			,       a_					:		int							)      ->				float:
      __SCREAMING_SNAKE_CASE       :Any		    =  float(2 * (random.randint(1			,       1_00							)) - 1							)

      for _ in range(a_							):
            # Forward propagation
            __SCREAMING_SNAKE_CASE       :Any		    =  sigmoid_function(INITIAL_VALUE * weight							)
            # How much did we miss?
            __SCREAMING_SNAKE_CASE       :Tuple		    =  (expected / 1_00) - layer_a
            # Error delta
            __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  layer_1_error * sigmoid_function(a_			,       a_							)
            # Update weight
            weight += INITIAL_VALUE * layer_1_delta

      return layer_a * 1_00


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  lowerCamelCase_       =		int(input("Expected value: "))
  lowerCamelCase_       =		int(input("Number of propagations: "))
  print(forward_propagation(expected, number_propagations))