
"""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 sys
import turtle




def     lowercase__						(					lowerCAmelCase				:					tuple[float, float] ,				lowerCAmelCase				:					tuple[float, float] ) ->      tuple[float, float]:






    """simple docstring"""




    return (pa[0] + pa[0]) / 2, (pa[1] + pa[1]) / 2




def     lowercase__						(					lowerCAmelCase				:					tuple[float, float] ,				lowerCAmelCase				:					tuple[float, float] ,				lowerCAmelCase				:					tuple[float, float] ,				lowerCAmelCase				:					int ,				) ->      None:






    """simple docstring"""




    my_pen.up()
    my_pen.goto(vertexa[0] ,				vertexa[1] )
    my_pen.down()
    my_pen.goto(vertexa[0] ,				vertexa[1] )
    my_pen.goto(vertexa[0] ,				vertexa[1] )
    my_pen.goto(vertexa[0] ,				vertexa[1] )

    if depth == 0:
        return

    triangle(lowerCAmelCase ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				depth - 1 )
    triangle(lowerCAmelCase ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				depth - 1 )
    triangle(lowerCAmelCase ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				depth - 1 )


if __name__ == "__main__":
   if len(sys.argv) != 2:
      raise ValueError(
          '''Correct format for using this script: '''
          '''python fractals.py <int:depth_for_fractal>'''
      )
   SCREAMING_SNAKE_CASE_    					=						turtle.Turtle()
   my_pen.ht()
   my_pen.speed(5)
   my_pen.pencolor('''red''')

   SCREAMING_SNAKE_CASE_    					=						[(-175, -125), (0, 175), (175, -125)]  # vertices of triangle
   triangle(vertices[0], vertices[1], vertices[2], int(sys.argv[1]))



