
import numpy

class __snake_case		:
    def __init__(  self		,snake_case		,snake_case				):



           '''simple docstring'''







           lowercase							:					Optional[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							:					Tuple	     =				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							:					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.
           lowercase							:					Any	     =				numpy.random.rand(3		,1				)

           # Real output values provided.
           lowercase							:					Optional[Any]	     =				output_array

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



           '''simple docstring'''







           lowercase							:					List[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							:					List[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							:					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 				_SCREAMING_SNAKE_CASE	(  self				):



           '''simple docstring'''







           lowercase							:					int	     =				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							:					List[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 				_SCREAMING_SNAKE_CASE	(  self		,snake_case		,snake_case		,snake_case				):



           '''simple docstring'''







           for iteration in range(1		,iterations + 1				):
                  lowercase							:					Optional[int]	     =				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 				_SCREAMING_SNAKE_CASE	(  self		,snake_case				):



           '''simple docstring'''







           lowercase							:					Union[str, Any]	     =				input_arr

           lowercase							:					Optional[Any]	     =				sigmoid(
               numpy.dot(self.array		,self.input_layer_and_first_hidden_layer_weights				)				)

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

           lowercase							:					Tuple	     =				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 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   numpy.ndarray:
       return 1 / (1 + numpy.exp(-value    ))







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   numpy.ndarray:
       return (value) * (1 - (value))







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

       # Calling neural network class.
       lowercase							:					Union[str, Any]	     =				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 ...processing_utils import ProcessorMixin

class __snake_case		(				lowerCAmelCase					):
    _a		:						Union[str, Any]=    "WhisperFeatureExtractor"
    _a		:						int=    "WhisperTokenizer"
    def __init__(  self		,snake_case		,snake_case				):



           '''simple docstring'''







           super().__init__(snake_case		,snake_case				)
           lowercase							:					Optional[int]	     =				self.feature_extractor
           lowercase							:					Tuple	     =				False
    def 				_SCREAMING_SNAKE_CASE	(  self		,snake_case=None		,snake_case=None		,snake_case=True				):



           '''simple docstring'''







           return self.tokenizer.get_decoder_prompt_ids(task=snake_case		,language=snake_case		,no_timestamps=snake_case				)
    def __call__(  self		,*snake_case		,**snake_case				):



           '''simple docstring'''







           if self._in_target_context_manager:
                  return self.current_processor(*snake_case		,**snake_case				)

           lowercase							:					Optional[Any]	     =				kwargs.pop("""audio"""		,snake_case				)
           lowercase							:					str	     =				kwargs.pop("""sampling_rate"""		,snake_case				)
           lowercase							:					Dict	     =				kwargs.pop("""text"""		,snake_case				)
           if len(snake_case				) > 0:
                  lowercase							:					List[Any]	     =				args[0]
                  lowercase							:					Tuple	     =				args[1:]

           if audio is None and text is None:
                  raise ValueError("""You need to specify either an `audio` or `text` input to process."""				)

           if audio is not None:
                  lowercase							:					Any	     =				self.feature_extractor(snake_case		,*snake_case		,sampling_rate=snake_case		,**snake_case				)
           if text is not None:
                  lowercase							:					str	     =				self.tokenizer(snake_case		,**snake_case				)

           if text is None:
                  return inputs

           elif audio is None:
                  return encodings
           else:
                  lowercase							:					List[Any]	     =				encodings["""input_ids"""]
                  return inputs
    def 				_SCREAMING_SNAKE_CASE	(  self		,*snake_case		,**snake_case				):



           '''simple docstring'''







           return self.tokenizer.batch_decode(*snake_case		,**snake_case				)
    def 				_SCREAMING_SNAKE_CASE	(  self		,*snake_case		,**snake_case				):



           '''simple docstring'''







           return self.tokenizer.decode(*snake_case		,**snake_case				)
    def 				_SCREAMING_SNAKE_CASE	(  self		,snake_case		,snake_case="np"				):



           '''simple docstring'''







           return self.tokenizer.get_prompt_ids(snake_case		,return_tensors=snake_case				)
