






'''simple docstring'''

import numpy






class 							__magic_name__     :







	"""simple docstring"""



	def __init__(							self  ,      _lowercase  ,      _lowercase       )						->  None:
							lowercase_      :   Optional[int]        =			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.
							lowercase_      :   Union[str, Any]        =			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.
							lowercase_      :   List[Any]        =			numpy.random.rand(
							    4  ,      3       )

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

							# Real output values provided.
							lowercase_      :   Any        =			output_array

							# Predicted output values by the neural network.
							# Predicted_output array initially consists of zeroes.
							lowercase_      :   Union[str, Any]        =			numpy.zeros(output_array.shape       )
	def        lowerCamelCase__		(							self       )						->  numpy.ndarray:
							lowercase_      :   List[str]        =			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.
							lowercase_      :   Optional[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.
							lowercase_      :   str        =			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        lowerCamelCase__		(							self       )						->  None:
							lowercase_      :   Union[str, 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       )  ,      )
							lowercase_      :   Optional[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       )  ,      )
							lowercase_      :   Tuple        =			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        lowerCamelCase__		(							self  ,      _lowercase  ,      _lowercase  ,      _lowercase       )						->  None:
							for iteration in range(1  ,      iterations + 1       ):
													lowercase_      :   Optional[Any]        =			self.feedforward()
													self.back_propagation()
													if give_loss:
																			lowercase_      :   str        =			numpy.mean(numpy.square(output - self.feedforward()       )       )
																			print(f"Iteration {iteration} Loss: {loss}"       )







	def        lowerCamelCase__		(							self  ,      _lowercase       )						->  int:
							lowercase_      :   List[str]        =			input_arr

							lowercase_      :   Any        =			sigmoid(
							    numpy.dot(self.array  ,      self.input_layer_and_first_hidden_layer_weights       )       )

							lowercase_      :   int        =			sigmoid(
							    numpy.dot(
							        self.layer_between_input_and_first_hidden_layer  ,      self.first_hidden_layer_and_second_hidden_layer_weights  ,      )       )

							lowercase_      :   List[str]        =			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 	_UpperCAmelCase    (  a		:	numpy.ndarray							)			->			str:





						"""simple docstring"""
						return 1 / (1 + numpy.exp(-value							))






def 	_UpperCAmelCase    (  a		:	numpy.ndarray							)			->			List[str]:





						"""simple docstring"""
						return (value) * (1 - (value))






def 	_UpperCAmelCase    (  )			->			Any:





						"""simple docstring"""
						lowercase_      :   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.
						lowercase_      :   Union[str, Any]        =			numpy.array(([0], [1], [1], [0], [1], [0], [0], [1])						,			dtype=numpy.floataa							)

						# Calling neural network class.
						lowercase_      :   Union[str, Any]        =			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=1_0						,			give_loss=a							)

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


if __name__ == "__main__":
			example()








'''simple docstring'''

import argparse


A:      List[Any]  				=				"docs/source/_static/js/custom.js"






def 	_UpperCAmelCase    (  a		:	Optional[Any]							)			->			Optional[Any]:





						"""simple docstring"""
						with open(a						,			encoding='utf-8'						,			newline='\n'							) as f:
												lowercase_      :   List[Any]        =			f.readlines()
						lowercase_      :   Dict        =			0

						# First let's put the right version
						while not lines[index].startswith('const stableVersion ='							):
												index += 1
						lowercase_      :   Dict        =			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(a						,			'w'						,			encoding='utf-8'						,			newline='\n'							) as f:
												f.writelines(a							)


if __name__ == "__main__":
						A:      str  				=				argparse.ArgumentParser()
						parser.add_argument("--version", help="Release version.")
						A:      List[str]  				=				parser.parse_args()
						update_custom_js(args.version)
