






'''simple docstring'''



import numpy
class UpperCAmelCase_       :




      """simple docstring"""




      def __init__(			self      :		Union[str, Any]  ,   UpperCAmelCase      :		numpy.ndarray  ,   UpperCAmelCase      :		numpy.ndarray		)	->	None:


       '''simple docstring'''

       lowercase       : 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       : str						=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       : 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.
       lowercase       : List[str]						=numpy.random.rand(3  ,   1		)

       # Real output values provided.
       lowercase       : Union[str, Any]						=output_array

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






      def 					A__   (			self      :		List[str]		)	->	numpy.ndarray:


       '''simple docstring'''

       lowercase       : Optional[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       : 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       : 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      :		Any		)	->	None:


       '''simple docstring'''

       lowercase       : List[Any]						=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       : Union[str, 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       : Optional[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 					A__   (			self      :		Tuple  ,   UpperCAmelCase      :		numpy.ndarray  ,   UpperCAmelCase      :		int  ,   UpperCAmelCase      :		bool		)	->	None:


       '''simple docstring'''

       for iteration in range(1  ,   iterations + 1		):
        lowercase       : Any						=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 					A__   (			self      :		Dict  ,   UpperCAmelCase      :		numpy.ndarray		)	->	int:


       '''simple docstring'''

       lowercase       : List[Any]						=input_arr

       lowercase       : int						=sigmoid(
           numpy.dot(self.array  ,   self.input_layer_and_first_hidden_layer_weights		)		)

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

       lowercase       : 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 				lowercase_					(     __A			:							numpy.ndarray      )							->   numpy.ndarray:



 """simple docstring"""




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


def 				lowercase_					(     __A			:							numpy.ndarray      )							->   numpy.ndarray:



 """simple docstring"""




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


def 				lowercase_					(     )							->   int:



 """simple docstring"""




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

 # Calling neural network class.
 lowercase       : Tuple						=TwoHiddenLayerNeuralNetwork(
     input_array=__A       ,   output_array=__A      )

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

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


if __name__ == "__main__":
      example()









import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
__magic_name__  :  Tuple					=       data_utils.TransfoXLTokenizer
__magic_name__  :  int					=       data_utils.TransfoXLCorpus
__magic_name__  :  List[str]					=       data_utils
__magic_name__  :  str					=       data_utils
def 		a_							( __lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase				):
  if transfo_xl_dataset_file:
    # Convert a pre-processed corpus (see original TensorFlow repo)
    with open(__lowerCAmelCase   , '''rb'''				) as fp:
      lowerCAmelCase__										=      pickle.load(__lowerCAmelCase   , encoding='''latin1'''				)
    # Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
    lowerCAmelCase__										=      pytorch_dump_folder_path + '''/''' + VOCAB_FILES_NAMES['''pretrained_vocab_file''']
    print(F"""Save vocabulary to {pytorch_vocab_dump_path}"""				)
    lowerCAmelCase__										=      corpus.vocab.__dict__
    torch.save(__lowerCAmelCase   , __lowerCAmelCase				)

    lowerCAmelCase__										=      corpus.__dict__
    corpus_dict_no_vocab.pop('''vocab'''   , __lowerCAmelCase				)
    lowerCAmelCase__										=      pytorch_dump_folder_path + '''/''' + CORPUS_NAME
    print(F"""Save dataset to {pytorch_dataset_dump_path}"""				)
    torch.save(__lowerCAmelCase   , __lowerCAmelCase				)

  if tf_checkpoint_path:
    # Convert a pre-trained TensorFlow model
    lowerCAmelCase__										=      os.path.abspath(__lowerCAmelCase				)
    lowerCAmelCase__										=      os.path.abspath(__lowerCAmelCase				)

    print(F"""Converting Transformer XL checkpoint from {tf_path} with config at {config_path}."""				)
    # Initialise PyTorch model
    if transfo_xl_config_file == "":
      lowerCAmelCase__										=      TransfoXLConfig()
    else:
      lowerCAmelCase__										=      TransfoXLConfig.from_json_file(__lowerCAmelCase				)
    print(F"""Building PyTorch model from configuration: {config}"""				)
    lowerCAmelCase__										=      TransfoXLLMHeadModel(__lowerCAmelCase				)

    lowerCAmelCase__										=      load_tf_weights_in_transfo_xl(__lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase				)
    # Save pytorch-model
    lowerCAmelCase__										=      os.path.join(__lowerCAmelCase   , __lowerCAmelCase				)
    lowerCAmelCase__										=      os.path.join(__lowerCAmelCase   , __lowerCAmelCase				)
    print(F"""Save PyTorch model to {os.path.abspath(__lowerCAmelCase				)}"""				)
    torch.save(model.state_dict()   , __lowerCAmelCase				)
    print(F"""Save configuration file to {os.path.abspath(__lowerCAmelCase				)}"""				)
    with open(__lowerCAmelCase   , '''w'''   , encoding='''utf-8'''				) as f:
      f.write(config.to_json_string()				)


if __name__ == "__main__":
      __magic_name__  :  int					=       argparse.ArgumentParser()
      parser.add_argument(
          """--pytorch_dump_folder_path""",
          default=None,
          type=str,
          required=True,
          help="""Path to the folder to store the PyTorch model or dataset/vocab.""",
      )
      parser.add_argument(
          """--tf_checkpoint_path""",
          default="""""",
          type=str,
          help="""An optional path to a TensorFlow checkpoint path to be converted.""",
      )
      parser.add_argument(
          """--transfo_xl_config_file""",
          default="""""",
          type=str,
          help=(
              """An optional config json file corresponding to the pre-trained BERT model. \n"""
              """This specifies the model architecture."""
          ),
      )
      parser.add_argument(
          """--transfo_xl_dataset_file""",
          default="""""",
          type=str,
          help="""An optional dataset file to be converted in a vocabulary.""",
      )
      __magic_name__  :  Optional[Any]					=       parser.parse_args()
      convert_transfo_xl_checkpoint_to_pytorch(
          args.tf_checkpoint_path,
          args.transfo_xl_config_file,
          args.pytorch_dump_folder_path,
          args.transfo_xl_dataset_file,
      )

