






'''simple docstring'''



import numpy
class UpperCAmelCase_       :




      """simple docstring"""




      def __init__(			self      :		Union[str, Any]  ,   UpperCAmelCase      :		numpy.ndarray  ,   UpperCAmelCase      :		numpy.ndarray		)	->	None:


       '''simple docstring'''

       lowercase       : Any						=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       : str						=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       : int						=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       : List[str]						=numpy.random.rand(3  ,   1		)

       # Real output values provided.
       lowercase       : Union[str, Any]						=output_array

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






      def 					A__   (			self      :		List[str]		)	->	numpy.ndarray:


       '''simple docstring'''

       lowercase       : 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.
       lowercase       : 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       : Optional[int]						=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      :		Any		)	->	None:


       '''simple docstring'''

       lowercase       : List[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       : 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		)  ,   )
       lowercase       : 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 					A__   (			self      :		Tuple  ,   UpperCAmelCase      :		numpy.ndarray  ,   UpperCAmelCase      :		int  ,   UpperCAmelCase      :		bool		)	->	None:


       '''simple docstring'''

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






      def 					A__   (			self      :		Dict  ,   UpperCAmelCase      :		numpy.ndarray		)	->	int:


       '''simple docstring'''

       lowercase       : List[Any]						=input_arr

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

       lowercase       : List[str]						=sigmoid(
           numpy.dot(
               self.layer_between_input_and_first_hidden_layer  ,   self.first_hidden_layer_and_second_hidden_layer_weights  ,   )		)

       lowercase       : Optional[Any]						=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_					(     __A			:							numpy.ndarray      )							->   numpy.ndarray:



 """simple docstring"""




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


def 				lowercase_					(     __A			:							numpy.ndarray      )							->   numpy.ndarray:



 """simple docstring"""




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


def 				lowercase_					(     )							->   int:



 """simple docstring"""




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

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










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


UpperCAmelCase_							=				{
    """configuration_m2m_100""": ["""M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP""", """M2M100Config""", """M2M100OnnxConfig"""],
    """tokenization_m2m_100""": ["""M2M100Tokenizer"""],
}


try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase_							=				[
							    """M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """M2M100ForConditionalGeneration""",
							    """M2M100Model""",
							    """M2M100PreTrainedModel""",
							]


if TYPE_CHECKING:
							from .configuration_mam_aaa import M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP, MaMaaaConfig, MaMaaaOnnxConfig
							from .tokenization_mam_aaa import MaMaaaTokenizer

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_mam_aaa import (
														    M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST,
														    MaMaaaForConditionalGeneration,
														    MaMaaaModel,
														    MaMaaaPreTrainedModel,
														)


else:
							import sys

							UpperCAmelCase_							=				_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)