


'''simple docstring'''



import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


__A		='\n@inproceedings{xu-etal-2016-optimizing,\n    title = {Optimizing Statistical Machine Translation for Text Simplification},\n    authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},\n    journal = {Transactions of the Association for Computational Linguistics},\n    volume = {4},\n    year={2016},\n    url = {https://www.aclweb.org/anthology/Q16-1029},\n    pages = {401--415\n},\n@inproceedings{post-2018-call,\n    title = "A Call for Clarity in Reporting {BLEU} Scores",\n    author = "Post, Matt",\n    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n    month = oct,\n    year = "2018",\n    address = "Belgium, Brussels",\n    publisher = "Association for Computational Linguistics",\n    url = "https://www.aclweb.org/anthology/W18-6319",\n    pages = "186--191",\n}\n'

__A		='\\nWIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU\nIt can be used to evaluate the quality of machine-generated texts.\n'


__A		='\nCalculates sari score (between 0 and 100) given a list of source and predicted\nsentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.\nArgs:\n    sources: list of source sentences where each sentence should be a string.\n    predictions: list of predicted sentences where each sentence should be a string.\n    references: list of lists of reference sentences where each sentence should be a string.\nReturns:\n    sari: sari score\n    sacrebleu: sacrebleu score\n    exact: exact score\n\nExamples:\n    >>> sources=["About 95 species are currently accepted ."]\n    >>> predictions=["About 95 you now get in ."]\n    >>> references=[["About 95 species are currently known ."]]\n    >>> wiki_split = datasets.load_metric("wiki_split")\n    >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)\n    >>> print(results)\n    {\'sari\': 21.805555555555557, \'sacrebleu\': 14.535768424205482, \'exact\': 0.0}\n'







def       _UpperCamelCase (						UpperCamelCase__   ):

   def remove_articles(UpperCamelCase__   ):
      UpperCAmelCase__					:   Tuple       				=       re.compile(R"""\b(a|an|the)\b"""	, re.UNICODE   )
      return re.sub(UpperCamelCase__	, """ """	, UpperCamelCase__   )

   def white_space_fix(UpperCamelCase__   ):
      return " ".join(text.split()   )

   def remove_punc(UpperCamelCase__   ):
      UpperCAmelCase__					:   int       				=       set(string.punctuation   )
      return "".join(ch for ch in text if ch not in exclude   )

   def lower(UpperCamelCase__   ):
      return text.lower()

   return white_space_fix(remove_articles(remove_punc(lower(UpperCamelCase__   )   )   )   )







def       _UpperCamelCase (						UpperCamelCase__	, UpperCamelCase__   ):
   return int(normalize_answer(UpperCamelCase__   ) == normalize_answer(UpperCamelCase__   )   )







def       _UpperCamelCase (						UpperCamelCase__	, UpperCamelCase__   ):
   UpperCAmelCase__					:   Any       				=       [any(compute_exact(UpperCamelCase__	, UpperCamelCase__   ) for ref in refs   ) for pred, refs in zip(UpperCamelCase__	, UpperCamelCase__   )]
   return (sum(UpperCamelCase__   ) / len(UpperCamelCase__   )) * 1_0_0







def       _UpperCamelCase (						UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__   ):
   UpperCAmelCase__					:   List[Any]       				=       [rgram for rgrams in rgramslist for rgram in rgrams]
   UpperCAmelCase__					:   List[Any]       				=       Counter(UpperCamelCase__   )

   UpperCAmelCase__					:   str       				=       Counter(UpperCamelCase__   )
   UpperCAmelCase__					:   Dict       				=       Counter()
   for sgram, scount in sgramcounter.items():
      UpperCAmelCase__					:   Dict       				=       scount * numref

   UpperCAmelCase__					:   int       				=       Counter(UpperCamelCase__   )
   UpperCAmelCase__					:   Optional[int]       				=       Counter()
   for cgram, ccount in cgramcounter.items():
      UpperCAmelCase__					:   Union[str, Any]       				=       ccount * numref

   # KEEP
   UpperCAmelCase__					:   str       				=       sgramcounter_rep & cgramcounter_rep
   UpperCAmelCase__					:   List[Any]       				=       keepgramcounter_rep & rgramcounter
   UpperCAmelCase__					:   Dict       				=       sgramcounter_rep & rgramcounter

   UpperCAmelCase__					:   str       				=       0
   UpperCAmelCase__					:   Union[str, Any]       				=       0
   for keepgram in keepgramcountergood_rep:
      keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram]
      # Fix an alleged bug [2] in the keep score computation.
      # keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram]
      keeptmpscorea += keepgramcountergood_rep[keepgram]
   # Define 0/0=1 instead of 0 to give higher scores for predictions that match
   #      a target exactly.
   UpperCAmelCase__					:   List[str]       				=       1
   UpperCAmelCase__					:   Optional[Any]       				=       1
   if len(UpperCamelCase__   ) > 0:
      UpperCAmelCase__					:   Optional[int]       				=       keeptmpscorea / len(UpperCamelCase__   )
   if len(UpperCamelCase__   ) > 0:
      # Fix an alleged bug [2] in the keep score computation.
      # keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
      UpperCAmelCase__					:   Any       				=       keeptmpscorea / sum(keepgramcounterall_rep.values()   )
   UpperCAmelCase__					:   Any       				=       0
   if keepscore_precision > 0 or keepscore_recall > 0:
      UpperCAmelCase__					:   str       				=       2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

   # DELETION
   UpperCAmelCase__					:   str       				=       sgramcounter_rep - cgramcounter_rep
   UpperCAmelCase__					:   Optional[Any]       				=       delgramcounter_rep - rgramcounter
   UpperCAmelCase__					:   List[str]       				=       sgramcounter_rep - rgramcounter
   UpperCAmelCase__					:   str       				=       0
   UpperCAmelCase__					:   List[Any]       				=       0
   for delgram in delgramcountergood_rep:
      deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram]
      deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram]
   # Define 0/0=1 instead of 0 to give higher scores for predictions that match
   # a target exactly.
   UpperCAmelCase__					:   Union[str, Any]       				=       1
   if len(UpperCamelCase__   ) > 0:
      UpperCAmelCase__					:   Optional[Any]       				=       deltmpscorea / len(UpperCamelCase__   )

   # ADDITION
   UpperCAmelCase__					:   Tuple       				=       set(UpperCamelCase__   ) - set(UpperCamelCase__   )
   UpperCAmelCase__					:   Optional[Any]       				=       set(UpperCamelCase__   ) & set(UpperCamelCase__   )
   UpperCAmelCase__					:   List[str]       				=       set(UpperCamelCase__   ) - set(UpperCamelCase__   )

   UpperCAmelCase__					:   str       				=       0
   for addgram in addgramcountergood:
      addtmpscore += 1

   # Define 0/0=1 instead of 0 to give higher scores for predictions that match
   # a target exactly.
   UpperCAmelCase__					:   List[Any]       				=       1
   UpperCAmelCase__					:   List[Any]       				=       1
   if len(UpperCamelCase__   ) > 0:
      UpperCAmelCase__					:   Optional[int]       				=       addtmpscore / len(UpperCamelCase__   )
   if len(UpperCamelCase__   ) > 0:
      UpperCAmelCase__					:   int       				=       addtmpscore / len(UpperCamelCase__   )
   UpperCAmelCase__					:   Tuple       				=       0
   if addscore_precision > 0 or addscore_recall > 0:
      UpperCAmelCase__					:   int       				=       2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

   return (keepscore, delscore_precision, addscore)







def       _UpperCamelCase (						UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__   ):
   UpperCAmelCase__					:   Dict       				=       len(UpperCamelCase__   )

   UpperCAmelCase__					:   Tuple       				=       ssent.split(""" """   )
   UpperCAmelCase__					:   Optional[int]       				=       csent.split(""" """   )
   UpperCAmelCase__					:   Union[str, Any]       				=       []
   UpperCAmelCase__					:   Tuple       				=       []
   UpperCAmelCase__					:   Any       				=       []
   UpperCAmelCase__					:   Optional[Any]       				=       []
   UpperCAmelCase__					:   Any       				=       []
   UpperCAmelCase__					:   Tuple       				=       []

   UpperCAmelCase__					:   Optional[Any]       				=       []
   UpperCAmelCase__					:   Union[str, Any]       				=       []
   UpperCAmelCase__					:   Dict       				=       []
   UpperCAmelCase__					:   List[Any]       				=       []
   for rsent in rsents:
      UpperCAmelCase__					:   List[str]       				=       rsent.split(""" """   )
      UpperCAmelCase__					:   Dict       				=       []
      UpperCAmelCase__					:   str       				=       []
      UpperCAmelCase__					:   Dict       				=       []
      ragramslist.append(UpperCamelCase__   )
      for i in range(0	, len(UpperCamelCase__   ) - 1   ):
         if i < len(UpperCamelCase__   ) - 1:
            UpperCAmelCase__					:   Optional[int]       				=       ragrams[i] + """ """ + ragrams[i + 1]
            ragrams.append(UpperCamelCase__   )
         if i < len(UpperCamelCase__   ) - 2:
            UpperCAmelCase__					:   Union[str, Any]       				=       ragrams[i] + """ """ + ragrams[i + 1] + """ """ + ragrams[i + 2]
            ragrams.append(UpperCamelCase__   )
         if i < len(UpperCamelCase__   ) - 3:
            UpperCAmelCase__					:   Any       				=       ragrams[i] + """ """ + ragrams[i + 1] + """ """ + ragrams[i + 2] + """ """ + ragrams[i + 3]
            ragrams.append(UpperCamelCase__   )
      ragramslist.append(UpperCamelCase__   )
      ragramslist.append(UpperCamelCase__   )
      ragramslist.append(UpperCamelCase__   )

   for i in range(0	, len(UpperCamelCase__   ) - 1   ):
      if i < len(UpperCamelCase__   ) - 1:
         UpperCAmelCase__					:   Optional[int]       				=       sagrams[i] + """ """ + sagrams[i + 1]
         sagrams.append(UpperCamelCase__   )
      if i < len(UpperCamelCase__   ) - 2:
         UpperCAmelCase__					:   Dict       				=       sagrams[i] + """ """ + sagrams[i + 1] + """ """ + sagrams[i + 2]
         sagrams.append(UpperCamelCase__   )
      if i < len(UpperCamelCase__   ) - 3:
         UpperCAmelCase__					:   str       				=       sagrams[i] + """ """ + sagrams[i + 1] + """ """ + sagrams[i + 2] + """ """ + sagrams[i + 3]
         sagrams.append(UpperCamelCase__   )

   for i in range(0	, len(UpperCamelCase__   ) - 1   ):
      if i < len(UpperCamelCase__   ) - 1:
         UpperCAmelCase__					:   Dict       				=       cagrams[i] + """ """ + cagrams[i + 1]
         cagrams.append(UpperCamelCase__   )
      if i < len(UpperCamelCase__   ) - 2:
         UpperCAmelCase__					:   int       				=       cagrams[i] + """ """ + cagrams[i + 1] + """ """ + cagrams[i + 2]
         cagrams.append(UpperCamelCase__   )
      if i < len(UpperCamelCase__   ) - 3:
         UpperCAmelCase__					:   List[Any]       				=       cagrams[i] + """ """ + cagrams[i + 1] + """ """ + cagrams[i + 2] + """ """ + cagrams[i + 3]
         cagrams.append(UpperCamelCase__   )

   (UpperCAmelCase__)					:   Optional[Any]       				=       SARIngram(UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__   )
   (UpperCAmelCase__)					:   str       				=       SARIngram(UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__   )
   (UpperCAmelCase__)					:   Any       				=       SARIngram(UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__   )
   (UpperCAmelCase__)					:   Optional[int]       				=       SARIngram(UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__   )
   UpperCAmelCase__					:   Tuple       				=       sum([keepascore, keepascore, keepascore, keepascore]   ) / 4
   UpperCAmelCase__					:   Union[str, Any]       				=       sum([delascore, delascore, delascore, delascore]   ) / 4
   UpperCAmelCase__					:   Dict       				=       sum([addascore, addascore, addascore, addascore]   ) / 4
   UpperCAmelCase__					:   List[Any]       				=       (avgkeepscore + avgdelscore + avgaddscore) / 3
   return finalscore







def       _UpperCamelCase (						UpperCamelCase__	, UpperCamelCase__ = True	, UpperCamelCase__ = "13a"	, UpperCamelCase__ = True   ):
   # Normalization is requried for the ASSET dataset (one of the primary
   # datasets in sentence simplification) to allow using space
   # to split the sentence. Even though Wiki-Auto and TURK datasets,
   # do not require normalization, we do it for consistency.
   # Code adapted from the EASSE library [1] written by the authors of the ASSET dataset.
   # [1] https://github.com/feralvam/easse/blob/580bba7e1378fc8289c663f864e0487188fe8067/easse/utils/preprocessing.py#L7

   if lowercase:
      UpperCAmelCase__					:   List[str]       				=       sentence.lower()

   if tokenizer in ["13a", "intl"]:
      if version.parse(sacrebleu.__version__   ).major >= 2:
         UpperCAmelCase__					:   Tuple       				=       sacrebleu.metrics.bleu._get_tokenizer(UpperCamelCase__   )()(UpperCamelCase__   )
      else:
         UpperCAmelCase__					:   Tuple       				=       sacrebleu.TOKENIZERS[tokenizer]()(UpperCamelCase__   )
   elif tokenizer == "moses":
      UpperCAmelCase__					:   Union[str, Any]       				=       sacremoses.MosesTokenizer().tokenize(UpperCamelCase__	, return_str=UpperCamelCase__	, escape=UpperCamelCase__   )
   elif tokenizer == "penn":
      UpperCAmelCase__					:   Dict       				=       sacremoses.MosesTokenizer().penn_tokenize(UpperCamelCase__	, return_str=UpperCamelCase__   )
   else:
      UpperCAmelCase__					:   List[Any]       				=       sentence

   if not return_str:
      UpperCAmelCase__					:   List[str]       				=       normalized_sent.split()

   return normalized_sent







def       _UpperCamelCase (						UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__   ):
   if not (len(UpperCamelCase__   ) == len(UpperCamelCase__   ) == len(UpperCamelCase__   )):
      raise ValueError("""Sources length must match predictions and references lengths."""   )
   UpperCAmelCase__					:   Optional[int]       				=       0
   for src, pred, refs in zip(UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__   ):
      sari_score += SARIsent(normalize(UpperCamelCase__   )	, normalize(UpperCamelCase__   )	, [normalize(UpperCamelCase__   ) for sent in refs]   )
   UpperCAmelCase__					:   Optional[int]       				=       sari_score / len(UpperCamelCase__   )
   return 1_0_0 * sari_score







def       _UpperCamelCase (						UpperCamelCase__	, UpperCamelCase__	, UpperCamelCase__="exp"	, UpperCamelCase__=None	, UpperCamelCase__=False	, UpperCamelCase__=False	, UpperCamelCase__=False	, ):
   UpperCAmelCase__					:   int       				=       len(references[0]   )
   if any(len(UpperCamelCase__   ) != references_per_prediction for refs in references   ):
      raise ValueError("""Sacrebleu requires the same number of references for each prediction"""   )
   UpperCAmelCase__					:   int       				=       [[refs[i] for refs in references] for i in range(UpperCamelCase__   )]
   UpperCAmelCase__					:   int       				=       sacrebleu.corpus_bleu(
       UpperCamelCase__	, UpperCamelCase__	, smooth_method=UpperCamelCase__	, smooth_value=UpperCamelCase__	, force=UpperCamelCase__	, lowercase=UpperCamelCase__	, use_effective_order=UpperCamelCase__	, )
   return output.score


@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,				_KWARGS_DESCRIPTION		)
class 						_snake_case   (       datasets.Metric		):




     def 			snake_case__  ( self):
        return datasets.MetricInfo(
            description=_DESCRIPTION							,							citation=_CITATION							,							inputs_description=_KWARGS_DESCRIPTION							,							features=datasets.Features(
                {
                    """predictions""": datasets.Value("""string"""							,							id="""sequence"""),
                    """references""": datasets.Sequence(datasets.Value("""string"""							,							id="""sequence""")							,							id="""references"""),
                })							,							codebase_urls=[
                """https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py""",
                """https://github.com/cocoxu/simplification/blob/master/SARI.py""",
                """https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py""",
                """https://github.com/mjpost/sacreBLEU""",
            ]							,							reference_urls=[
                """https://www.aclweb.org/anthology/Q16-1029.pdf""",
                """https://github.com/mjpost/sacreBLEU""",
                """https://en.wikipedia.org/wiki/BLEU""",
                """https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213""",
            ]							,							)




     def 			snake_case__  ( self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
        UpperCAmelCase__					:   Union[str, Any]       				=       {}
        result.update({"""sari""": compute_sari(sources=_lowerCamelCase							,							predictions=_lowerCamelCase							,							references=_lowerCamelCase)})
        result.update({"""sacrebleu""": compute_sacrebleu(predictions=_lowerCamelCase							,							references=_lowerCamelCase)})
        result.update({"""exact""": compute_em(predictions=_lowerCamelCase							,							references=_lowerCamelCase)})
        return result



'''simple docstring'''



import numpy


class 						_snake_case   :




					def __init__( self							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__					:   Dict       				=       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.
								UpperCAmelCase__					:   Optional[Any]       				=       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.
								UpperCAmelCase__					:   Optional[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.
								UpperCAmelCase__					:   Any       				=       numpy.random.rand(3							,							1)

								# Real output values provided.
								UpperCAmelCase__					:   Tuple       				=       output_array

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




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   List[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.
								UpperCAmelCase__					:   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.
								UpperCAmelCase__					:   Tuple       				=       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):
								UpperCAmelCase__					:   Optional[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)							,							)
								UpperCAmelCase__					:   str       				=       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)							,							)
								UpperCAmelCase__					:   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 			snake_case__  ( self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								for iteration in range(1							,							iterations + 1):
											UpperCAmelCase__					:   Optional[Any]       				=       self.feedforward()
											self.back_propagation()
											if give_loss:
														UpperCAmelCase__					:   str       				=       numpy.mean(numpy.square(output - self.feedforward()))
														print(f'''Iteration {iteration} Loss: {loss}''')




					def 			snake_case__  ( self							,							_lowerCamelCase):
								UpperCAmelCase__					:   List[Any]       				=       input_arr

								UpperCAmelCase__					:   Tuple       				=       sigmoid(
								    numpy.dot(self.array							,							self.input_layer_and_first_hidden_layer_weights))

								UpperCAmelCase__					:   List[Any]       				=       sigmoid(
								    numpy.dot(
								        self.layer_between_input_and_first_hidden_layer							,							self.first_hidden_layer_and_second_hidden_layer_weights							,							))

								UpperCAmelCase__					:   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       _UpperCamelCase (						UpperCamelCase__   ):
			return 1 / (1 + numpy.exp(-value   ))







def       _UpperCamelCase (						UpperCamelCase__   ):
			return (value) * (1 - (value))







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

			# Calling neural network class.
			UpperCAmelCase__					:   List[Any]       				=       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=1_0	, give_loss=UpperCamelCase__   )

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


if __name__ == "__main__":
		example()