

import numpy



class     _a						:


					'''simple docstring'''






					def __init__( self    ,       A__    ,       A__			):
						A__							:    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.
						A__							:    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.
						A__							:    List[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.
						A__							:    Any        =		numpy.random.rand(3    ,       1			)

						# Real output values provided.
						A__							:    int        =		output_array

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






					def   __A			( self			):
						A__							:    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.
						A__							:    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.
						A__							:    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			):
						A__							:    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			)    ,       )
						A__							:    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			)    ,       )
						A__							:    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   __A			( self    ,       A__    ,       A__    ,       A__			):
						for iteration in range(1    ,       iterations + 1			):
							A__							:    Any        =		self.feedforward()
							self.back_propagation()
							if give_loss:
								A__							:    Optional[Any]        =		numpy.mean(numpy.square(output - self.feedforward()			)			)
								print(F"""Iteration {iteration} Loss: {loss}"""			)






					def   __A			( self    ,       A__			):
						A__							:    Dict        =		input_arr

						A__							:    Optional[int]        =		sigmoid(
						    numpy.dot(self.array    ,       self.input_layer_and_first_hidden_layer_weights			)			)

						A__							:    Tuple        =		sigmoid(
						    numpy.dot(
						        self.layer_between_input_and_first_hidden_layer    ,       self.first_hidden_layer_and_second_hidden_layer_weights    ,       )			)

						A__							:    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 						UpperCamelCase					(lowercase_: numpy.ndarray					)     ->      Optional[int]:
	return 1 / (1 + numpy.exp(-value					))

def 						UpperCamelCase					(lowercase_: numpy.ndarray					)     ->      Optional[int]:
	return (value) * (1 - (value))

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

	# Calling neural network class.
	A__							:    Tuple        =		TwoHiddenLayerNeuralNetwork(
	    input_array=UpperCAmelCase_    ,      output_array=UpperCAmelCase_					)

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

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


if __name__ == "__main__":
	example()







'''simple docstring'''

import unittest

from transformers import MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING, AutoTokenizer, is_vision_available
from transformers.pipelines import pipeline
from transformers.pipelines.document_question_answering import apply_tesseract
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_detectrona,
    require_pytesseract,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
     from PIL import Image

     from transformers.image_utils import load_image
else:





     class      snake_case    :





       """simple docstring"""




       @staticmethod
       def   snake_case		(    *UpperCamelCase			,  **UpperCamelCase     ):







        """simple docstring"""
        pass





     def __snake_case					(      UpperCAmelCase_						:						List[Any]		):
      return None


# This is a pinned image from a specific revision of a document question answering space, hosted by HuggingFace,
# so we can expect it to be available.
a_  :				Dict						= (
    """https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png"""
)





@is_pipeline_test
@require_torch
@require_vision
class      snake_case    (    unittest.TestCase			):





  """simple docstring"""




  _lowerCamelCase		    =  MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING






  @require_pytesseract
  @require_vision
  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  pipeline(
       "document-question-answering"			,  model=UpperCamelCase			,  tokenizer=UpperCamelCase			,  image_processor=UpperCamelCase     )

   lowerCamelCase_      =  INVOICE_URL
   lowerCamelCase_      =  list(zip(*apply_tesseract(load_image(UpperCamelCase     )			,  UpperCamelCase			,  ""     )     )     )
   lowerCamelCase_      =  "What is the placebo?"
   lowerCamelCase_      =  [
       {
           "image": load_image(UpperCamelCase     ),
           "question": question,
       },
       {
           "image": image,
           "question": question,
       },
       {
           "image": image,
           "question": question,
           "word_boxes": word_boxes,
       },
   ]
   return dqa_pipeline, examples






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  dqa_pipeline(UpperCamelCase			,  top_k=2     )
   self.assertEqual(
       UpperCamelCase			,  [
           [
               {"score": ANY(UpperCamelCase     ), "answer": ANY(UpperCamelCase     ), "start": ANY(UpperCamelCase     ), "end": ANY(UpperCamelCase     )},
               {"score": ANY(UpperCamelCase     ), "answer": ANY(UpperCamelCase     ), "start": ANY(UpperCamelCase     ), "end": ANY(UpperCamelCase     )},
           ]
       ]
       * 3			,  )






  @require_torch
  @require_detectrona
  @require_pytesseract
  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  pipeline("document-question-answering"			,  model="hf-internal-testing/tiny-random-layoutlmv2"     )
   lowerCamelCase_      =  INVOICE_URL
   lowerCamelCase_      =  "How many cats are there?"

   lowerCamelCase_      =  [
       {"score": 0.0_001, "answer": "oy 2312/2019", "start": 38, "end": 39},
       {"score": 0.0_001, "answer": "oy 2312/2019 DUE", "start": 38, "end": 40},
   ]
   lowerCamelCase_      =  dqa_pipeline(image=UpperCamelCase			,  question=UpperCamelCase			,  top_k=2     )
   self.assertEqual(nested_simplify(UpperCamelCase			,  decimals=4     )			,  UpperCamelCase     )

   lowerCamelCase_      =  dqa_pipeline({"image": image, "question": question}			,  top_k=2     )
   self.assertEqual(nested_simplify(UpperCamelCase			,  decimals=4     )			,  UpperCamelCase     )

   # This image does not detect ANY text in it, meaning layoutlmv2 should fail.
   # Empty answer probably
   lowerCamelCase_      =  "./tests/fixtures/tests_samples/COCO/000000039769.png"
   lowerCamelCase_      =  dqa_pipeline(image=UpperCamelCase			,  question=UpperCamelCase			,  top_k=2     )
   self.assertEqual(UpperCamelCase			,  []     )

   # We can optionnally pass directly the words and bounding boxes
   lowerCamelCase_      =  "./tests/fixtures/tests_samples/COCO/000000039769.png"
   lowerCamelCase_      =  []
   lowerCamelCase_      =  []
   lowerCamelCase_      =  dqa_pipeline(image=UpperCamelCase			,  question=UpperCamelCase			,  words=UpperCamelCase			,  boxes=UpperCamelCase			,  top_k=2     )
   self.assertEqual(UpperCamelCase			,  []     )






  @slow
  @require_torch
  @require_detectrona
  @require_pytesseract
  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  pipeline(
       "document-question-answering"			,  model="tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa"			,  revision="9977165"			,  )
   lowerCamelCase_      =  INVOICE_URL
   lowerCamelCase_      =  "What is the invoice number?"

   lowerCamelCase_      =  dqa_pipeline(image=UpperCamelCase			,  question=UpperCamelCase			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           {"score": 0.9_944, "answer": "us-001", "start": 16, "end": 16},
           {"score": 0.0_009, "answer": "us-001", "start": 16, "end": 16},
       ]			,  )

   lowerCamelCase_      =  dqa_pipeline({"image": image, "question": question}			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           {"score": 0.9_944, "answer": "us-001", "start": 16, "end": 16},
           {"score": 0.0_009, "answer": "us-001", "start": 16, "end": 16},
       ]			,  )

   lowerCamelCase_      =  dqa_pipeline(
       [{"image": image, "question": question}, {"image": image, "question": question}]			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           [
               {"score": 0.9_944, "answer": "us-001", "start": 16, "end": 16},
               {"score": 0.0_009, "answer": "us-001", "start": 16, "end": 16},
           ],
       ]
       * 2			,  )






  @slow
  @require_torch
  @require_detectrona
  @require_pytesseract
  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  pipeline(
       "document-question-answering"			,  model="tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa"			,  revision="9977165"			,  max_seq_len=50			,  )
   lowerCamelCase_      =  INVOICE_URL
   lowerCamelCase_      =  "What is the invoice number?"

   lowerCamelCase_      =  dqa_pipeline(image=UpperCamelCase			,  question=UpperCamelCase			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           {"score": 0.9_974, "answer": "1110212019", "start": 23, "end": 23},
           {"score": 0.9_948, "answer": "us-001", "start": 16, "end": 16},
       ]			,  )

   lowerCamelCase_      =  dqa_pipeline({"image": image, "question": question}			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           {"score": 0.9_974, "answer": "1110212019", "start": 23, "end": 23},
           {"score": 0.9_948, "answer": "us-001", "start": 16, "end": 16},
       ]			,  )

   lowerCamelCase_      =  dqa_pipeline(
       [{"image": image, "question": question}, {"image": image, "question": question}]			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           [
               {"score": 0.9_974, "answer": "1110212019", "start": 23, "end": 23},
               {"score": 0.9_948, "answer": "us-001", "start": 16, "end": 16},
           ]
       ]
       * 2			,  )






  @slow
  @require_torch
  @require_pytesseract
  @require_vision
  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  AutoTokenizer.from_pretrained(
       "impira/layoutlm-document-qa"			,  revision="3dc6de3"			,  add_prefix_space=UpperCamelCase     )
   lowerCamelCase_      =  pipeline(
       "document-question-answering"			,  model="impira/layoutlm-document-qa"			,  tokenizer=UpperCamelCase			,  revision="3dc6de3"			,  )
   lowerCamelCase_      =  INVOICE_URL
   lowerCamelCase_      =  "What is the invoice number?"

   lowerCamelCase_      =  dqa_pipeline(image=UpperCamelCase			,  question=UpperCamelCase			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           {"score": 0.4_251, "answer": "us-001", "start": 16, "end": 16},
           {"score": 0.0_819, "answer": "1110212019", "start": 23, "end": 23},
       ]			,  )

   lowerCamelCase_      =  dqa_pipeline({"image": image, "question": question}			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           {"score": 0.4_251, "answer": "us-001", "start": 16, "end": 16},
           {"score": 0.0_819, "answer": "1110212019", "start": 23, "end": 23},
       ]			,  )

   lowerCamelCase_      =  dqa_pipeline(
       [{"image": image, "question": question}, {"image": image, "question": question}]			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           [
               {"score": 0.4_251, "answer": "us-001", "start": 16, "end": 16},
               {"score": 0.0_819, "answer": "1110212019", "start": 23, "end": 23},
           ]
       ]
       * 2			,  )

   lowerCamelCase_      =  list(zip(*apply_tesseract(load_image(UpperCamelCase     )			,  UpperCamelCase			,  ""     )     )     )

   # This model should also work if `image` is set to None
   lowerCamelCase_      =  dqa_pipeline({"image": None, "word_boxes": word_boxes, "question": question}			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           {"score": 0.4_251, "answer": "us-001", "start": 16, "end": 16},
           {"score": 0.0_819, "answer": "1110212019", "start": 23, "end": 23},
       ]			,  )






  @slow
  @require_torch
  @require_pytesseract
  @require_vision
  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  AutoTokenizer.from_pretrained(
       "impira/layoutlm-document-qa"			,  revision="3dc6de3"			,  add_prefix_space=UpperCamelCase     )
   lowerCamelCase_      =  pipeline(
       "document-question-answering"			,  model="impira/layoutlm-document-qa"			,  tokenizer=UpperCamelCase			,  revision="3dc6de3"			,  max_seq_len=50			,  )
   lowerCamelCase_      =  INVOICE_URL
   lowerCamelCase_      =  "What is the invoice number?"

   lowerCamelCase_      =  dqa_pipeline(image=UpperCamelCase			,  question=UpperCamelCase			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           {"score": 0.9_999, "answer": "us-001", "start": 16, "end": 16},
           {"score": 0.9_998, "answer": "us-001", "start": 16, "end": 16},
       ]			,  )

   lowerCamelCase_      =  dqa_pipeline(
       [{"image": image, "question": question}, {"image": image, "question": question}]			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           [
               {"score": 0.9_999, "answer": "us-001", "start": 16, "end": 16},
               {"score": 0.9_998, "answer": "us-001", "start": 16, "end": 16},
           ]
       ]
       * 2			,  )

   lowerCamelCase_      =  list(zip(*apply_tesseract(load_image(UpperCamelCase     )			,  UpperCamelCase			,  ""     )     )     )

   # This model should also work if `image` is set to None
   lowerCamelCase_      =  dqa_pipeline({"image": None, "word_boxes": word_boxes, "question": question}			,  top_k=2     )
   self.assertEqual(
       nested_simplify(UpperCamelCase			,  decimals=4     )			,  [
           {"score": 0.9_999, "answer": "us-001", "start": 16, "end": 16},
           {"score": 0.9_998, "answer": "us-001", "start": 16, "end": 16},
       ]			,  )






  @slow
  @require_torch
  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  pipeline(
       "document-question-answering"			,  model="naver-clova-ix/donut-base-finetuned-docvqa"			,  tokenizer=AutoTokenizer.from_pretrained("naver-clova-ix/donut-base-finetuned-docvqa"     )			,  feature_extractor="naver-clova-ix/donut-base-finetuned-docvqa"			,  )

   lowerCamelCase_      =  INVOICE_URL
   lowerCamelCase_      =  "What is the invoice number?"
   lowerCamelCase_      =  dqa_pipeline(image=UpperCamelCase			,  question=UpperCamelCase			,  top_k=2     )
   self.assertEqual(nested_simplify(UpperCamelCase			,  decimals=4     )			,  [{"answer": "us-001"}]     )







  @require_tf
  @unittest.skip("Document question answering not implemented in TF"     )
  def   snake_case		(    self     ):







   """simple docstring"""
   pass



