





import numpy







class 			__A       :




      """simple docstring"""







      def __init__(		self      ,							a__      ,							a__):



             """simple docstring"""





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

             # Real output values provided.
             _lowerCamelCase							:     str	=		output_array

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


      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     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.
             _lowerCamelCase							:     Tuple	=		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							:     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 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     List[str]	=		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							:     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)      ,							)
             _lowerCamelCase							:     int	=		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							:     Any	=		self.feedforward()
                    self.back_propagation()
                    if give_loss:
                           _lowerCamelCase							:     Tuple	=		numpy.mean(numpy.square(output - self.feedforward()))
                           print(F"""Iteration {iteration} Loss: {loss}""")



      def 				__snake_case			(		self      ,							a__):



             """simple docstring"""





             _lowerCamelCase							:     Dict	=		input_arr

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

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

             _lowerCamelCase							:     List[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    __UpperCAmelCase(      lowercase_      ):
       return 1 / (1 + numpy.exp(-value      ))




def    __UpperCAmelCase(      lowercase_      ):
       return (value) * (1 - (value))




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

       # Calling neural network class.
       _lowerCamelCase							:     List[str]	=		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

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_lowerCamelCase			       =      {'configuration_opt': ['OPT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'OPTConfig']}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _lowerCamelCase			       =      [
           'OPT_PRETRAINED_MODEL_ARCHIVE_LIST',
           'OPTForCausalLM',
           'OPTModel',
           'OPTPreTrainedModel',
           'OPTForSequenceClassification',
           'OPTForQuestionAnswering',
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _lowerCamelCase			       =      ['TFOPTForCausalLM', 'TFOPTModel', 'TFOPTPreTrainedModel']

try:
       if not is_flax_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _lowerCamelCase			       =      [
           'FlaxOPTForCausalLM',
           'FlaxOPTModel',
           'FlaxOPTPreTrainedModel',
       ]


if TYPE_CHECKING:
       from .configuration_opt import OPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPTConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_opt import (
                  OPT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  OPTForCausalLM,
                  OPTForQuestionAnswering,
                  OPTForSequenceClassification,
                  OPTModel,
                  OPTPreTrainedModel,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_opt import TFOPTForCausalLM, TFOPTModel, TFOPTPreTrainedModel

       try:
              if not is_flax_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_flax_opt import FlaxOPTForCausalLM, FlaxOPTModel, FlaxOPTPreTrainedModel

else:
       import sys

       _lowerCamelCase			       =      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

