





"""simple docstring"""


import numpy







class       __a  :



     def __init__(			self   ,	a__   ,	a__  ):
            _lowerCamelCase             =   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.
            _lowerCamelCase             =   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.
            _lowerCamelCase             =   numpy.random.rand(
                4   ,	3  )

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

            # Real output values provided.
            _lowerCamelCase             =   output_array

            # Predicted output values by the neural network.
            # Predicted_output array initially consists of zeroes.
            _lowerCamelCase             =   numpy.zeros(output_array.shape  )



     def 		snake_case_     (			self  ):
            _lowerCamelCase             =   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.
            _lowerCamelCase             =   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.
            _lowerCamelCase             =   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  ):
            _lowerCamelCase             =   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  )   ,	)
            _lowerCamelCase             =   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  )   ,	)
            _lowerCamelCase             =   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   ,	a__   ,	a__   ,	a__  ):
            for iteration in range(1   ,	iterations + 1  ):
                   _lowerCamelCase             =   self.feedforward()
                   self.back_propagation()
                   if give_loss:
                          _lowerCamelCase             =   numpy.mean(numpy.square(output - self.feedforward()  )  )
                          print(F'Iteration {iteration} Loss: {loss}'  )



     def 		snake_case_     (			self   ,	a__  ):
            _lowerCamelCase             =   input_arr

            _lowerCamelCase             =   sigmoid(
                numpy.dot(self.array   ,	self.input_layer_and_first_hidden_layer_weights  )  )

            _lowerCamelCase             =   sigmoid(
                numpy.dot(
                    self.layer_between_input_and_first_hidden_layer   ,	self.first_hidden_layer_and_second_hidden_layer_weights   ,	)  )

            _lowerCamelCase             =   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 SCREAMING_SNAKE_CASE_  (			snake_case  :   int						)->						Optional[int]:
       return 1 / (1 + numpy.exp(-value						))





def SCREAMING_SNAKE_CASE_  (			snake_case  :   Optional[Any]						)->						Dict:
       return (value) * (1 - (value))





def SCREAMING_SNAKE_CASE_  (			)->						Optional[Any]:
       _lowerCamelCase             =   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.
       _lowerCamelCase             =   numpy.array(([0], [1], [1], [0], [1], [0], [0], [1])		,    dtype=numpy.floataa						)

       # Calling neural network class.
       _lowerCamelCase             =   TwoHiddenLayerNeuralNetwork(
           input_array=_A		,    output_array=_A						)

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

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


if __name__ == "__main__":
      example()











'''simple docstring'''






import numpy as np
def  lowerCamelCase__			(		_A							):
  return 1 / (1 + np.exp(-vector							))
def  lowerCamelCase__			(		_A							):
  return vector * sigmoid(1.702 * vector							)


if __name__ == "__main__":
     import doctest

     doctest.testmod()