



'''simple docstring'''





import numpy


class 				snake_case :



       def __init__(				self     ,UpperCAmelCase_     ,UpperCAmelCase_      )  ->							None:
           lowercase__		       =						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__		       =						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__		       =						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__		       =						numpy.random.rand(3     ,1      )

           # Real output values provided.
           lowercase__		       =						output_array

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



       def 							_a      (				self      )  ->							numpy.ndarray:
           lowercase__		       =						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__		       =						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__		       =						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      )  ->							None:
           lowercase__		       =						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__		       =						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__		       =						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     ,UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_      )  ->							None:
           for iteration in range(1     ,iterations + 1      ):
               lowercase__		       =						self.feedforward()
               self.back_propagation()
               if give_loss:
                   lowercase__		       =						numpy.mean(numpy.square(output - self.feedforward()      )      )
                   print(F'''Iteration {iteration} Loss: {loss}'''      )







       def 							_a      (				self     ,UpperCAmelCase_      )  ->							int:
           lowercase__		       =						input_arr

           lowercase__		       =						sigmoid(
               numpy.dot(self.array     ,self.input_layer_and_first_hidden_layer_weights      )      )

           lowercase__		       =						sigmoid(
               numpy.dot(
                   self.layer_between_input_and_first_hidden_layer     ,self.first_hidden_layer_and_second_hidden_layer_weights     ,)      )

           lowercase__		       =						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        lowerCamelCase  (				_snake_case  :						numpy.ndarray       ):





    '''simple docstring'''


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




def        lowerCamelCase  (				_snake_case  :						numpy.ndarray       ):





    '''simple docstring'''


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




def        lowerCamelCase  (				):





    '''simple docstring'''


    lowercase__		       =						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__		       =						numpy.array(([0], [1], [1], [0], [1], [0], [0], [1])     ,dtype=numpy.floataa       )

    # Calling neural network class.
    lowercase__		       =						TwoHiddenLayerNeuralNetwork(
        input_array=_snake_case     ,output_array=_snake_case       )

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

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


if __name__ == "__main__":
 example()









'''simple docstring'''





import os
import time

import numpy as np
import onnxruntime as ort


SCREAMING_SNAKE_CASE__      					=     "1"
SCREAMING_SNAKE_CASE__      					=     "0"
SCREAMING_SNAKE_CASE__      					=     "1"

SCREAMING_SNAKE_CASE__      					=     ort.SessionOptions()
SCREAMING_SNAKE_CASE__      					=     ort.GraphOptimizationLevel.ORT_DISABLE_ALL
print("Create inference session...")
SCREAMING_SNAKE_CASE__      					=     ["TensorrtExecutionProvider", "CUDAExecutionProvider"]
SCREAMING_SNAKE_CASE__      					=     ort.InferenceSession("model.onnx", sess_options=sess_opt, providers=execution_provider)
SCREAMING_SNAKE_CASE__      					=     ort.RunOptions()

SCREAMING_SNAKE_CASE__      					=     128
SCREAMING_SNAKE_CASE__      					=     1
SCREAMING_SNAKE_CASE__      					=     np.ones((batch, sequence), dtype=np.intaa)
SCREAMING_SNAKE_CASE__      					=     np.ones((batch, sequence), dtype=np.intaa)
SCREAMING_SNAKE_CASE__      					=     np.ones((batch, sequence), dtype=np.intaa)

print("Warm up phase...")
sess.run(
    None,
    {
        sess.get_inputs()[0].name: input_ids,
        sess.get_inputs()[1].name: attention_mask,
        sess.get_inputs()[2].name: token_type_ids,
    },
    run_options=run_opt,
)

print("Start inference...")
SCREAMING_SNAKE_CASE__      					=     time.time()
SCREAMING_SNAKE_CASE__      					=     2000
SCREAMING_SNAKE_CASE__      					=     {}
for iter in range(max_iters):
 SCREAMING_SNAKE_CASE__      					=     sess.run(
     None,
     {
         sess.get_inputs()[0].name: input_ids,
         sess.get_inputs()[1].name: attention_mask,
         sess.get_inputs()[2].name: token_type_ids,
     },
     run_options=run_opt,
 )
print("Average Inference Time = {:.3f} ms".format((time.time() - start_time) * 1000 / max_iters))




