



import numpy as np
from scipy.spatial.distance import cdist
from sklearn.metrics import fa_score

import datasets


UpperCAmelCase_									=							"\\n    @inproceedings{kakwani2020indicnlpsuite,\n    title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},\n    author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},\n    year={2020},\n    booktitle={Findings of EMNLP},\n}\n"

UpperCAmelCase_									=							"\\n    IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide\n    variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.\n"

UpperCAmelCase_									=							"\nCompute IndicGLUE evaluation metric associated to each IndicGLUE dataset.\nArgs:\n    predictions: list of predictions to score (as int64),\n        except for 'cvit-mkb-clsr' where each prediction is a vector (of float32).\n    references: list of ground truth labels corresponding to the predictions (as int64),\n        except for 'cvit-mkb-clsr' where each reference is a vector (of float32).\nReturns: depending on the IndicGLUE subset, one or several of:\n    \"accuracy\": Accuracy\n    \"f1\": F1 score\n    \"precision\": Precision@10\nExamples:\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'wnli')  # 'wnli' or any of [\"copa\", \"sna\", \"csqa\", \"wstp\", \"inltkh\", \"bbca\", \"iitp-mr\", \"iitp-pr\", \"actsa-sc\", \"md\"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'wiki-ner')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0, 'f1': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'cvit-mkb-clsr')\n    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'precision@10': 1.0}\n\n"
def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	Optional[Any]     ,				_SCREAMING_SNAKE_CASE   :	Optional[int]				)->Dict:
      return float((preds == labels).mean()				)
def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	Union[str, Any]     ,				_SCREAMING_SNAKE_CASE   :	Tuple				)->Dict:
      _lowerCAmelCase 			=  simple_accuracy(_SCREAMING_SNAKE_CASE     ,				_SCREAMING_SNAKE_CASE				)
      _lowerCAmelCase 			=  float(fa_score(y_true=_SCREAMING_SNAKE_CASE     ,				y_pred=_SCREAMING_SNAKE_CASE				)				)
      return {
          "accuracy": acc,
          "f1": fa,
      }
def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	Optional[int]     ,				_SCREAMING_SNAKE_CASE   :	str				)->Optional[int]:
      _lowerCAmelCase 			=  np.array(_SCREAMING_SNAKE_CASE				)
      _lowerCAmelCase 			=  np.array(_SCREAMING_SNAKE_CASE				)
      _lowerCAmelCase 			=  en_sentvecs.shape[0]

      # mean centering
      _lowerCAmelCase 			=  en_sentvecs - np.mean(_SCREAMING_SNAKE_CASE     ,				axis=0				)
      _lowerCAmelCase 			=  in_sentvecs - np.mean(_SCREAMING_SNAKE_CASE     ,				axis=0				)

      _lowerCAmelCase 			=  cdist(_SCREAMING_SNAKE_CASE     ,				_SCREAMING_SNAKE_CASE     ,				'''cosine'''				)
      _lowerCAmelCase 			=  np.array(range(_SCREAMING_SNAKE_CASE				)				)
      _lowerCAmelCase 			=  sim.argsort(axis=1				)[:, :1_0]
      _lowerCAmelCase 			=  np.any(preds == actual[:, None]     ,				axis=1				)
      return float(matches.mean()				)





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





   def 	__lowerCAmelCase							(	self			):
         if self.config_name not in [
             "wnli",
             "copa",
             "sna",
             "csqa",
             "wstp",
             "inltkh",
             "bbca",
             "cvit-mkb-clsr",
             "iitp-mr",
             "iitp-pr",
             "actsa-sc",
             "md",
             "wiki-ner",
         ]:
               raise KeyError(
                   '''You should supply a configuration name selected in '''
                   '''["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '''
                   '''"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '''
                   '''"wiki-ner"]'''			)
         return datasets.MetricInfo(
             description=_DESCRIPTION       ,     citation=_CITATION       ,     inputs_description=_KWARGS_DESCRIPTION       ,     features=datasets.Features(
                 {
                     '''predictions''': datasets.Value('''int64'''			)
                     if self.config_name != '''cvit-mkb-clsr'''
                     else datasets.Sequence(datasets.Value('''float32'''			)			),
                     '''references''': datasets.Value('''int64'''			)
                     if self.config_name != '''cvit-mkb-clsr'''
                     else datasets.Sequence(datasets.Value('''float32'''			)			),
                 }			)       ,     codebase_urls=[]       ,     reference_urls=[]       ,     format='''numpy''' if self.config_name != '''cvit-mkb-clsr''' else None       ,     )





   def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase			):
         if self.config_name == "cvit-mkb-clsr":
               return {"precision@10": precision_at_aa(_lowerCAmelCase       ,     _lowerCAmelCase			)}
         elif self.config_name in ["wiki-ner"]:
               return acc_and_fa(_lowerCAmelCase       ,     _lowerCAmelCase			)
         elif self.config_name in [
             "wnli",
             "copa",
             "sna",
             "csqa",
             "wstp",
             "inltkh",
             "bbca",
             "iitp-mr",
             "iitp-pr",
             "actsa-sc",
             "md",
         ]:
               return {"accuracy": simple_accuracy(_lowerCAmelCase       ,     _lowerCAmelCase			)}
         else:
               raise KeyError(
                   '''You should supply a configuration name selected in '''
                   '''["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '''
                   '''"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '''
                   '''"wiki-ner"]'''			)




import numpy





class 		UpperCAmelCase						:





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

         # Real output values provided.
         _lowerCAmelCase 			=  output_array

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





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





   def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase			):
         _lowerCAmelCase 			=  input_arr

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

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

         _lowerCAmelCase 			=  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__		(				_SCREAMING_SNAKE_CASE   :	numpy.ndarray				)->numpy.ndarray:
      return 1 / (1 + numpy.exp(-value				))
def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	numpy.ndarray				)->numpy.ndarray:
      return (value) * (1 - (value))
def 							UpperCAmelCase__		(				)->int:
      _lowerCAmelCase 			=  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 			=  numpy.array(([0], [1], [1], [0], [1], [0], [0], [1])     ,				dtype=numpy.floataa				)

      # Calling neural network class.
      _lowerCAmelCase 			=  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=1_0     ,				give_loss=_SCREAMING_SNAKE_CASE				)

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


if __name__ == "__main__":
    example()