





"""simple docstring"""



import numpy






class 						__snake_case   :





 """simple docstring"""


 def __init__(       self   ,		__lowerCamelCase   ,		__lowerCamelCase    ):



     '''simple docstring'''




     __A       :		Tuple							=	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       :		Tuple							=	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       :		List[str]							=	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       :		Optional[int]							=	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       :		Optional[Any]							=	numpy.zeros(output_array.shape    )

 def    UpperCamelCase__(       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    UpperCamelCase__(       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[Any]							=	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       :		Union[str, Any]							=	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    UpperCamelCase__(       self   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase    ):



     '''simple docstring'''




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







 def    UpperCamelCase__(       self   ,		__lowerCamelCase    ):



     '''simple docstring'''




     __A       :		Dict							=	input_arr

     __A       :		Dict							=	sigmoid(
         numpy.dot(self.array   ,		self.input_layer_and_first_hidden_layer_weights    )    )

     __A       :		str							=	sigmoid(
         numpy.dot(
             self.layer_between_input_and_first_hidden_layer   ,		self.first_hidden_layer_and_second_hidden_layer_weights   ,		)    )

     __A       :		Optional[Any]							=	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	(  snake_case_    :    numpy.ndarray		)  ->numpy.ndarray:



    '''simple docstring'''







    return 1 / (1 + numpy.exp(-value		))







def 						__lowercase	(  snake_case_    :    numpy.ndarray		)  ->numpy.ndarray:



    '''simple docstring'''







    return (value) * (1 - (value))







def 						__lowercase	(  )  ->int:



    '''simple docstring'''







    __A       :		List[str]							=	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       :		Tuple							=	numpy.array(([0], [1], [1], [0], [1], [0], [0], [1])							,dtype=numpy.floataa		)

    # Calling neural network class.
    __A       :		Dict							=	TwoHiddenLayerNeuralNetwork(
        input_array=snake_case_							,output_array=snake_case_		)

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

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


if __name__ == "__main__":
       example()











"""simple docstring"""



def 						__lowercase	(  snake_case_    :    list		)  ->float:



    '''simple docstring'''







    __A       :		Tuple							=	0
    while len(snake_case_		) > 1:
        __A       :		List[Any]							=	0
        # Consider two files with minimum cost to be merged
        for _ in range(2		):
            __A       :		Dict							=	files.index(min(snake_case_		)		)
            temp += files[min_index]
            files.pop(snake_case_		)
        files.append(snake_case_		)
        optimal_merge_cost += temp
    return optimal_merge_cost


if __name__ == "__main__":
       import doctest

       doctest.testmod()




