





"""simple docstring"""


import numpy






class 							lowercase__			:

			"""simple docstring"""







			def __init__(      self						,   _A						,   _A    ):






									'''simple docstring'''







									UpperCamelCase				:		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.
									UpperCamelCase				:		Optional[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.
									UpperCamelCase				:		Union[str, 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.
									UpperCamelCase				:		Dict				   =			numpy.random.rand(3						,   1    )

									# Real output values provided.
									UpperCamelCase				:		Dict				   =			output_array

									# Predicted output values by the neural network.
									# Predicted_output array initially consists of zeroes.
									UpperCamelCase				:		Optional[Any]				   =			numpy.zeros(output_array.shape    )







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		Tuple				   =			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				:		Optional[int]				   =			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				:		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   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		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    )						,   )
									UpperCamelCase				:		List[str]				   =			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				:		List[str]				   =			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						,   _A						,   _A						,   _A    ):






									'''simple docstring'''







									for iteration in range(1						,   iterations + 1    ):
															UpperCamelCase				:		int				   =			self.feedforward()
															self.back_propagation()
															if give_loss:
																					UpperCamelCase				:		Dict				   =			numpy.mean(numpy.square(output - self.feedforward()    )    )
																					print(f"""Iteration {iteration} Loss: {loss}"""    )







			def   _a      (      self						,   _A    ):






									'''simple docstring'''







									UpperCamelCase				:		List[Any]				   =			input_arr

									UpperCamelCase				:		int				   =			sigmoid(
									    numpy.dot(self.array						,   self.input_layer_and_first_hidden_layer_weights    )    )

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

									UpperCamelCase				:		int				   =			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							(SCREAMING_SNAKE_CASE     ):
						return 1 / (1 + numpy.exp(-value     ))

def      UpperCamelCase							(SCREAMING_SNAKE_CASE     ):
						return (value) * (1 - (value))

def      UpperCamelCase							():
						UpperCamelCase				:		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.
						UpperCamelCase				:		Optional[int]				   =			numpy.array(([0], [1], [1], [0], [1], [0], [0], [1])							,     dtype=numpy.floataa     )

						# Calling neural network class.
						UpperCamelCase				:		Dict				   =			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()









from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__magic_name__  :  Optional[Any]					=       {
    """configuration_informer""": [
        """INFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """InformerConfig""",
    ],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __magic_name__  :  int					=       [
          """INFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """InformerForPrediction""",
          """InformerModel""",
          """InformerPreTrainedModel""",
      ]


if TYPE_CHECKING:
      from .configuration_informer import INFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, InformerConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_informer import (
                INFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                InformerForPrediction,
                InformerModel,
                InformerPreTrainedModel,
            )

else:
      import sys

      __magic_name__  :  Any					=       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

