


import numpy
class 	UpperCAmelCase_					:

   '''simple docstring'''




   def __init__(		self						,				__A						,				__A ):






     """simple docstring"""





     lowerCamelCase :					Dict    =				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 :					Optional[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.
     lowerCamelCase :					Tuple    =				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 :					Optional[Any]    =				numpy.random.rand(3						,				1 )

     # Real output values provided.
     lowerCamelCase :					Any    =				output_array

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






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					Optional[Any]    =				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 :					List[str]    =				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 :					Tuple    =				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"""





     lowerCamelCase :					Dict    =				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 :					Union[str, 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 )						,				)
     lowerCamelCase :					Optional[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 _snake_case    (		self						,				__A						,				__A						,				__A ):






     """simple docstring"""





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






   def _snake_case    (		self						,				__A ):






     """simple docstring"""





     lowerCamelCase :					Optional[int]    =				input_arr

     lowerCamelCase :					Optional[Any]    =				sigmoid(
         numpy.dot(self.array						,				self.input_layer_and_first_hidden_layer_weights ) )

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

     lowerCamelCase :					Dict    =				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_(  SCREAMING_SNAKE_CASE_	):


  '''simple docstring'''

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






def 		lowercase_(  SCREAMING_SNAKE_CASE_	):


  '''simple docstring'''

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






def 		lowercase_(  ):


  '''simple docstring'''

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

  # Calling neural network class.
  lowerCamelCase :					Any    =				TwoHiddenLayerNeuralNetwork(
      input_array=SCREAMING_SNAKE_CASE_      ,						output_array=SCREAMING_SNAKE_CASE_	)

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

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


if __name__ == "__main__":
   example()







import argparse


_snake_case             =     '''docs/source/_static/js/custom.js'''






def 		lowercase_(  SCREAMING_SNAKE_CASE_	):


  '''simple docstring'''

  with open(SCREAMING_SNAKE_CASE_      ,						encoding="utf-8"      ,						newline="\n"	) as f:
    lowerCamelCase :					List[str]    =				f.readlines()
  lowerCamelCase :					int    =				0

  # First let's put the right version
  while not lines[index].startswith("const stableVersion ="	):
    index += 1
  lowerCamelCase :					str    =				f"""const stableVersion = \"v{version}\"\n"""

  # Then update the dictionary
  while not lines[index].startswith("const versionMapping = {"	):
    index += 1

  # We go until the end
  while not lines[index].startswith("}"	):
    index += 1
  # We add the new version at the end
  lines[index - 1] += f"""    \"v{version}\": \"v{version}\",\n"""

  with open(SCREAMING_SNAKE_CASE_      ,						"w"      ,						encoding="utf-8"      ,						newline="\n"	) as f:
    f.writelines(SCREAMING_SNAKE_CASE_	)


if __name__ == "__main__":
   _snake_case             =     argparse.ArgumentParser()
   parser.add_argument('''--version''', help='''Release version.''')
   _snake_case             =     parser.parse_args()
   update_custom_js(args.version)



