


'''simple docstring'''
import numpy

class     _lowerCamelCase       :




 '''simple docstring'''


 def __init__(   self   ,   __lowercase   ,   __lowercase    ):

  """simple docstring"""







  __A	:		Any	  =      input_array

  # Random initial weights are assigned where first argument is the
  # number of nodes in previous layer and second argument is the
  # number of nodes in the next layer.

  # Random initial weights are assigned.
  # self.input_array.shape[1] is used to represent number of nodes in input layer.
  # First hidden layer consists of 4 nodes.
  __A	:		int	  =      numpy.random.rand(
      self.input_array.shape[1]   ,   4    )

  # Random initial values for the first hidden layer.
  # First hidden layer has 4 nodes.
  # Second hidden layer has 3 nodes.
  __A	:		Optional[Any]	  =      numpy.random.rand(
      4   ,   3    )

  # Random initial values for the second hidden layer.
  # Second hidden layer has 3 nodes.
  # Output layer has 1 node.
  __A	:		str	  =      numpy.random.rand(3   ,   1    )

  # Real output values provided.
  __A	:		Dict	  =      output_array

  # Predicted output values by the neural network.
  # Predicted_output array initially consists of zeroes.
  __A	:		Union[str, Any]	  =      numpy.zeros(output_array.shape    )


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		Optional[int]	  =      sigmoid(
      numpy.dot(self.input_array   ,   self.input_layer_and_first_hidden_layer_weights    )    )

  # layer_between_first_hidden_layer_and_second_hidden_layer is the layer
  # connecting the first hidden set of nodes with the second hidden set of nodes.
  __A	:		Union[str, Any]	  =      sigmoid(
      numpy.dot(
          self.layer_between_input_and_first_hidden_layer   ,   self.first_hidden_layer_and_second_hidden_layer_weights   ,   )    )

  # layer_between_second_hidden_layer_and_output is the layer connecting
  # second hidden layer with the output node.
  __A	:		Union[str, Any]	  =      sigmoid(
      numpy.dot(
          self.layer_between_first_hidden_layer_and_second_hidden_layer   ,   self.second_hidden_layer_and_output_layer_weights   ,   )    )

  return self.layer_between_second_hidden_layer_and_output


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		Optional[Any]	  =      numpy.dot(
      self.layer_between_first_hidden_layer_and_second_hidden_layer.T   ,   2
      * (self.output_array - self.predicted_output)
      * sigmoid_derivative(self.predicted_output    )   ,   )
  __A	:		List[str]	  =      numpy.dot(
      self.layer_between_input_and_first_hidden_layer.T   ,   numpy.dot(
          2
          * (self.output_array - self.predicted_output)
          * sigmoid_derivative(self.predicted_output    )   ,   self.second_hidden_layer_and_output_layer_weights.T   ,   )
      * sigmoid_derivative(
          self.layer_between_first_hidden_layer_and_second_hidden_layer    )   ,   )
  __A	:		List[str]	  =      numpy.dot(
      self.input_array.T   ,   numpy.dot(
          numpy.dot(
              2
              * (self.output_array - self.predicted_output)
              * sigmoid_derivative(self.predicted_output    )   ,   self.second_hidden_layer_and_output_layer_weights.T   ,   )
          * sigmoid_derivative(
              self.layer_between_first_hidden_layer_and_second_hidden_layer    )   ,   self.first_hidden_layer_and_second_hidden_layer_weights.T   ,   )
      * sigmoid_derivative(self.layer_between_input_and_first_hidden_layer    )   ,   )

  self.input_layer_and_first_hidden_layer_weights += (
      updated_input_layer_and_first_hidden_layer_weights
  )
  self.first_hidden_layer_and_second_hidden_layer_weights += (
      updated_first_hidden_layer_and_second_hidden_layer_weights
  )
  self.second_hidden_layer_and_output_layer_weights += (
      updated_second_hidden_layer_and_output_layer_weights
  )


 def 			snake_case__ (   self   ,   __lowercase   ,   __lowercase   ,   __lowercase    ):

  """simple docstring"""







  for iteration in range(1   ,   iterations + 1    ):
   __A	:		Union[str, Any]	  =      self.feedforward()
   self.back_propagation()
   if give_loss:
    __A	:		Union[str, Any]	  =      numpy.mean(numpy.square(output - self.feedforward()    )    )
    print(F"""Iteration {iteration} Loss: {loss}"""    )







 def 			snake_case__ (   self   ,   __lowercase    ):

  """simple docstring"""







  __A	:		Tuple	  =      input_arr

  __A	:		List[Any]	  =      sigmoid(
      numpy.dot(self.array   ,   self.input_layer_and_first_hidden_layer_weights    )    )

  __A	:		Optional[int]	  =      sigmoid(
      numpy.dot(
          self.layer_between_input_and_first_hidden_layer   ,   self.first_hidden_layer_and_second_hidden_layer_weights   ,   )    )

  __A	:		List[str]	  =      sigmoid(
      numpy.dot(
          self.layer_between_first_hidden_layer_and_second_hidden_layer   ,   self.second_hidden_layer_and_output_layer_weights   ,   )    )

  return int(self.layer_between_second_hidden_layer_and_output > 0.6    )


def       _lowercase							(					UpperCamelCase__							:       numpy.ndarray      ):
 return 1 / (1 + numpy.exp(-value      ))


def       _lowercase							(					UpperCamelCase__							:       numpy.ndarray      ):
 return (value) * (1 - (value))


def       _lowercase							(					):
 __A	:		Optional[int]	  =      numpy.array(
     (
         [0, 0, 0],
         [0, 0, 1],
         [0, 1, 0],
         [0, 1, 1],
         [1, 0, 0],
         [1, 0, 1],
         [1, 1, 0],
         [1, 1, 1],
     ),					dtype=numpy.floataa,					)

 # True output values for the given input values.
 __A	:		Any	  =      numpy.array(([0], [1], [1], [0], [1], [0], [0], [1]),					dtype=numpy.floataa      )

 # Calling neural network class.
 __A	:		int	  =      TwoHiddenLayerNeuralNetwork(
     input_array=UpperCamelCase__,					output_array=UpperCamelCase__      )

 # Calling training function.
 # Set give_loss to True if you want to see loss in every iteration.
 neural_network.train(output=UpperCamelCase__,					iterations=10,					give_loss=UpperCamelCase__      )

 return neural_network.predict(numpy.array(([1, 1, 1]),					dtype=numpy.floataa      )      )


if __name__ == "__main__":
 example()










'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCAmelCase_			:  Optional[Any]										=   {
    'configuration_transfo_xl': ['TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TransfoXLConfig'],
    'tokenization_transfo_xl': ['TransfoXLCorpus', 'TransfoXLTokenizer'],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  Any										=   [
     'TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'AdaptiveEmbedding',
     'TransfoXLForSequenceClassification',
     'TransfoXLLMHeadModel',
     'TransfoXLModel',
     'TransfoXLPreTrainedModel',
     'load_tf_weights_in_transfo_xl',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  Optional[Any]										=   [
     'TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFAdaptiveEmbedding',
     'TFTransfoXLForSequenceClassification',
     'TFTransfoXLLMHeadModel',
     'TFTransfoXLMainLayer',
     'TFTransfoXLModel',
     'TFTransfoXLPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
 from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_transfo_xl import (
      TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      AdaptiveEmbedding,
      TransfoXLForSequenceClassification,
      TransfoXLLMHeadModel,
      TransfoXLModel,
      TransfoXLPreTrainedModel,
      load_tf_weights_in_transfo_xl,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_transfo_xl import (
      TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFAdaptiveEmbedding,
      TFTransfoXLForSequenceClassification,
      TFTransfoXLLMHeadModel,
      TFTransfoXLMainLayer,
      TFTransfoXLModel,
      TFTransfoXLPreTrainedModel,
  )

else:
 import sys

 UpperCAmelCase_			:  Optional[int]										=   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






