
"""simple docstring"""

import numpy
class   _UpperCAmelCase				:




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

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

          # Real output values provided.
          UpperCAmelCase          =       output_array

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




      def      a_   (				self				)    ->       numpy.ndarray:
          UpperCAmelCase          =       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.
          UpperCAmelCase          =       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.
          UpperCAmelCase          =       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      a_   (				self				)    ->       None:
          UpperCAmelCase          =       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				) ,							)
          UpperCAmelCase          =       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				) ,							)
          UpperCAmelCase          =       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      a_   (				self ,							lowercase_ ,							lowercase_ ,							lowercase_				)    ->       None:
          for iteration in range(1 ,							iterations + 1				):
              UpperCAmelCase          =       self.feedforward()
              self.back_propagation()
              if give_loss:
                  UpperCAmelCase          =       numpy.mean(numpy.square(output - self.feedforward()				)				)
                  print(F"Iteration {iteration} Loss: {loss}"				)




      def      a_   (				self ,							lowercase_				)    ->       int:
          UpperCAmelCase          =       input_arr

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

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

          UpperCAmelCase          =       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__    (       lowerCAmelCase					:       numpy.ndarray			)			->   numpy.ndarray:






    """simple docstring"""




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




def      lowercase__    (       lowerCAmelCase					:       numpy.ndarray			)			->   numpy.ndarray:






    """simple docstring"""




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




def      lowercase__    (       )			->   int:






    """simple docstring"""




    UpperCAmelCase          =       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.
    UpperCAmelCase          =       numpy.array(([0], [1], [1], [0], [1], [0], [0], [1])			,					dtype=numpy.floataa			)

    # Calling neural network class.
    UpperCAmelCase          =       TwoHiddenLayerNeuralNetwork(
        input_array=lowerCAmelCase			,					output_array=lowerCAmelCase			)

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

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


if __name__ == "__main__":
   example()





"""simple docstring"""

import math




def      lowercase__    (       lowerCAmelCase					:       str			,					lowerCAmelCase					:       Optional[Any]			)			->   List[Any]:






    """simple docstring"""




    if 0 not in (x, y):
        # We use the relation x^y = y*log10(x), where 10 is the base.
        return y * math.logaa(lowerCAmelCase			)
    else:
        if x == 0:  # 0 raised to any number is 0
            return 0
        elif y == 0:
            return 1  # any number raised to 0 is 1
    raise AssertionError('This should never happen'			)


if __name__ == "__main__":  # Main function
   # Read two numbers from input and typecast them to int using map function.
   # Here x is the base and y is the power.
   SCREAMING_SNAKE_CASE_            =    '''Enter the base and the power separated by a comma: '''
   SCREAMING_SNAKE_CASE_       ,    SCREAMING_SNAKE_CASE_            =    map(int, input(prompt).split(''','''))
   SCREAMING_SNAKE_CASE_       ,    SCREAMING_SNAKE_CASE_            =    map(int, input(prompt).split(''','''))

   # We find the log of each number, using the function res(), which takes two
   # arguments.
   SCREAMING_SNAKE_CASE_            =    res(xa, ya)
   SCREAMING_SNAKE_CASE_            =    res(xa, ya)

   # We check for the largest number
   if resa > resa:
      print('''Largest number is''', xa, '''^''', ya)
   elif resa > resa:
      print('''Largest number is''', xa, '''^''', ya)
   else:
      print('''Both are equal''')



