code: 
  
  
  
  
  
  
  import numpy as np
  from matplotlib import pyplot as plt
  def        UpperCAmelCase      (   _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      return 1 / (1 + np.exp(-1 * x      ))
  
  class 					snake_case_							:
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     def __init__(    self:	Optional[Any]   ,       snake_case__:	str   ,       snake_case__:	int=None   ,       snake_case__:	Tuple=None   ,       snake_case__:	Optional[int]=False	)  ->		List[str]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	units
         _lowercase     =	None
         _lowercase     =	None
         _lowercase     =	activation
         if learning_rate is None:
             _lowercase     =	0.3
         _lowercase     =	learning_rate
         _lowercase     =	is_input_layer
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Dict   ,       snake_case__:	Tuple	)  ->		Dict:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	np.asmatrix(np.random.normal(0   ,       0.5   ,       (self.units, back_units)	)	)
         _lowercase     =	np.asmatrix(np.random.normal(0   ,       0.5   ,       self.units	)	).T
         if self.activation is None:
             _lowercase     =	sigmoid
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Tuple	)  ->		Optional[Any]:
  
  
         """simple docstring"""
  
  
  
         if self.activation == sigmoid:
             _lowercase     =	np.dot(self.output   ,       (1 - self.output).T	)
             _lowercase     =	np.diag(np.diag(snake_case__	)	)
         else:
             _lowercase     =	1
         return gradient_activation
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	List[Any]   ,       snake_case__:	List[str]	)  ->		List[Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	xdata
         if self.is_input_layer:
             # input layer
             _lowercase     =	xdata
             _lowercase     =	xdata
             return xdata
         else:
             _lowercase     =	np.dot(self.weight   ,       self.xdata	) - self.bias
             _lowercase     =	self.activation(self.wx_plus_b	)
             return self.output
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Dict   ,       snake_case__:	List[str]	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.cal_gradient()  # i * i 维
         _lowercase     =	np.asmatrix(np.dot(gradient.T   ,       snake_case__	)	)
  
         _lowercase     =	np.asmatrix(self.xdata	)
         _lowercase     =	-1
         _lowercase     =	self.weight
  
         _lowercase     =	np.dot(gradient.T   ,       self._gradient_weight.T	)
         _lowercase     =	gradient * self._gradient_bias
         _lowercase     =	np.dot(snake_case__   ,       self._gradient_x	).T
         # upgrade: the Negative gradient direction
         _lowercase     =	self.weight - self.learn_rate * self.gradient_weight
         _lowercase     =	self.bias - self.learn_rate * self.gradient_bias.T
         # updates the weights and bias according to learning rate (0.3 if undefined)
         return self.gradient
  
  
  
  
  
  
  class 					snake_case_							:
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     def __init__(    self:	Union[str, Any]	)  ->		Union[str, Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	[]
         _lowercase     =	[]
         _lowercase     =	plt.figure()
         _lowercase     =	self.fig_loss.add_subplot(1   ,       1   ,       1	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Dict   ,       snake_case__:	Optional[int]	)  ->		str:
  
  
         """simple docstring"""
  
  
  
         self.layers.append(snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		Tuple:
  
  
         """simple docstring"""
  
  
  
         for i, layer in enumerate(self.layers[:]	):
             if i < 1:
                 _lowercase     =	True
             else:
                 layer.initializer(self.layers[i - 1].units	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         for i, layer in enumerate(self.layers[:]	):
             print(f'''------- layer {i} -------'''	)
             print('weight.shape '   ,       np.shape(layer.weight	)	)
             print('bias.shape '   ,       np.shape(layer.bias	)	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Tuple   ,       snake_case__:	Union[str, Any]   ,       snake_case__:	Tuple   ,       snake_case__:	List[str]   ,       snake_case__:	Dict	)  ->		List[str]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	train_round
         _lowercase     =	accuracy
  
         self.ax_loss.hlines(self.accuracy   ,       0   ,       self.train_round * 1.1	)
  
         _lowercase     =	np.shape(snake_case__	)
         for _ in range(snake_case__	):
             _lowercase     =	0
             for row in range(x_shape[0]	):
                 _lowercase     =	np.asmatrix(xdata[row, :]	).T
                 _lowercase     =	np.asmatrix(ydata[row, :]	).T
  
                 # forward propagation
                 for layer in self.layers:
                     _lowercase     =	layer.forward_propagation(_xdata	)
  
                 _lowercase ,    _lowercase     =	self.cal_loss(_ydata   ,       _xdata	)
                 _lowercase     =	all_loss + loss
  
                 # back propagation: the input_layer does not upgrade
                 for layer in self.layers[:0:-1]:
                     _lowercase     =	layer.back_propagation(snake_case__	)
  
             _lowercase     =	all_loss / x_shape[0]
             self.train_mse.append(snake_case__	)
  
             self.plot_loss()
  
             if mse < self.accuracy:
                 print('----达到精度----'	)
                 return mse
         return None
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	List[str]   ,       snake_case__:	List[str]   ,       snake_case__:	List[Any]	)  ->		Optional[int]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	np.sum(np.power((ydata - ydata_)   ,       2	)	)
         _lowercase     =	2 * (ydata_ - ydata)
         # vector (shape is the same as _ydata.shape)
         return self.loss, self.loss_gradient
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	int	)  ->		Any:
  
  
         """simple docstring"""
  
  
  
         if self.ax_loss.lines:
             self.ax_loss.lines.remove(self.ax_loss.lines[0]	)
         self.ax_loss.plot(self.train_mse   ,       'r-'	)
         plt.ion()
         plt.xlabel('step'	)
         plt.ylabel('loss'	)
         plt.show()
         plt.pause(0.1	)
  
  
  
  
  
  
  def        UpperCAmelCase      (   ):
  
  
      '''simple docstring'''
  
  
  
      _lowercase     =	np.random.randn(10,      10      )
      _lowercase     =	np.asarray(
          [
              [0.8, 0.4],
              [0.4, 0.3],
              [0.34, 0.45],
              [0.67, 0.32],
              [0.88, 0.67],
              [0.78, 0.77],
              [0.55, 0.66],
              [0.55, 0.43],
              [0.54, 0.1],
              [0.1, 0.5],
          ]      )
      _lowercase     =	BPNN()
      for i in (10, 20, 30, 2):
          model.add_layer(DenseLayer(_lowercase      )      )
      model.build()
      model.summary()
      model.train(xdata=_lowercase,      ydata=_lowercase,      train_round=100,      accuracy=0.01      )
  
  
  if __name__ == "__main__":
     example()
  
style_context: 
  
  
  
  
  
  
  import json
  import os
  import shutil
  import tempfile
  import unittest
  
  from transformers import is_speech_available, is_torch_available
  from transformers.models.speechta import SpeechTaTokenizer
  from transformers.testing_utils import get_tests_dir, require_torch
  from transformers.utils import FEATURE_EXTRACTOR_NAME
  
  
  if is_speech_available() and is_torch_available():
     from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor
  
     from .test_feature_extraction_speechta import floats_list
  
  
  lowerCamelCase										=  get_tests_dir('''fixtures/test_sentencepiece_bpe_char.model''')
  
  @require_torch
  class 					snake_case_							(       unittest.TestCase      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	List[str]	)  ->		Union[str, Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	tempfile.mkdtemp()
  
         _lowercase     =	SpeechTaTokenizer(snake_case__	)
         tokenizer.save_pretrained(self.tmpdirname	)
  
         _lowercase     =	{
             'feature_size': 1,
             'padding_value': 0.0,
             'sampling_rate': 16_000,
             'do_normalize': False,
             'num_mel_bins': 80,
             'hop_length': 16,
             'win_length': 64,
             'win_function': 'hann_window',
             'fmin': 80,
             'fmax': 7_600,
             'mel_floor': 1E-10,
             'reduction_factor': 2,
             'return_attention_mask': True,
         }
  
         _lowercase     =	os.path.join(self.tmpdirname   ,       snake_case__	)
         with open(self.feature_extraction_file   ,       'w'   ,       encoding='utf-8'	) as fp:
             fp.write(json.dumps(snake_case__	) + '\n'	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Union[str, Any]   ,       **snake_case__:	Union[str, Any]	)  ->		Union[str, Any]:
  
  
         """simple docstring"""
  
  
  
         return SpeechTaTokenizer.from_pretrained(self.tmpdirname   ,       **snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]   ,       **snake_case__:	str	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname   ,       **snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		Optional[int]:
  
  
         """simple docstring"""
  
  
  
         shutil.rmtree(self.tmpdirname	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	int	)  ->		List[str]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_tokenizer()
         _lowercase     =	self.get_feature_extractor()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         processor.save_pretrained(self.tmpdirname	)
         _lowercase     =	SpeechTaProcessor.from_pretrained(self.tmpdirname	)
  
         self.assertEqual(processor.tokenizer.get_vocab()   ,       tokenizer.get_vocab()	)
         self.assertIsInstance(processor.tokenizer   ,       snake_case__	)
  
         self.assertEqual(processor.feature_extractor.to_json_string()   ,       feature_extractor.to_json_string()	)
         self.assertIsInstance(processor.feature_extractor   ,       snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	int	)  ->		Any:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	SpeechTaProcessor(tokenizer=self.get_tokenizer()   ,       feature_extractor=self.get_feature_extractor()	)
         processor.save_pretrained(self.tmpdirname	)
  
         _lowercase     =	self.get_tokenizer(bos_token='(BOS)'   ,       eos_token='(EOS)'	)
         _lowercase     =	self.get_feature_extractor(do_normalize=snake_case__   ,       padding_value=1.0	)
  
         _lowercase     =	SpeechTaProcessor.from_pretrained(
             self.tmpdirname   ,       bos_token='(BOS)'   ,       eos_token='(EOS)'   ,       do_normalize=snake_case__   ,       padding_value=1.0	)
  
         self.assertEqual(processor.tokenizer.get_vocab()   ,       tokenizer_add_kwargs.get_vocab()	)
         self.assertIsInstance(processor.tokenizer   ,       snake_case__	)
  
         self.assertEqual(processor.feature_extractor.to_json_string()   ,       feature_extractor_add_kwargs.to_json_string()	)
         self.assertIsInstance(processor.feature_extractor   ,       snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Union[str, Any]	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         _lowercase     =	floats_list((3, 1_000)	)
  
         _lowercase     =	feature_extractor(audio=snake_case__   ,       return_tensors='np'	)
         _lowercase     =	processor(audio=snake_case__   ,       return_tensors='np'	)
  
         for key in input_feat_extract.keys():
             self.assertAlmostEqual(input_feat_extract[key].sum()   ,       input_processor[key].sum()   ,       delta=1E-2	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Tuple	)  ->		List[str]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         _lowercase     =	floats_list((3, 1_000)	)
  
         _lowercase     =	feature_extractor(audio_target=snake_case__   ,       return_tensors='np'	)
         _lowercase     =	processor(audio_target=snake_case__   ,       return_tensors='np'	)
  
         for key in input_feat_extract.keys():
             self.assertAlmostEqual(input_feat_extract[key].sum()   ,       input_processor[key].sum()   ,       delta=1E-2	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		Dict:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         _lowercase     =	'This is a test string'
  
         _lowercase     =	processor(text=snake_case__	)
         _lowercase     =	tokenizer(snake_case__	)
  
         for key in encoded_tok.keys():
             self.assertListEqual(encoded_tok[key]   ,       encoded_processor[key]	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         _lowercase     =	'This is a test string'
  
         _lowercase     =	processor(text_target=snake_case__	)
         _lowercase     =	tokenizer(snake_case__	)
  
         for key in encoded_tok.keys():
             self.assertListEqual(encoded_tok[key]   ,       encoded_processor[key]	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         _lowercase     =	[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
         _lowercase     =	processor.batch_decode(snake_case__	)
         _lowercase     =	tokenizer.batch_decode(snake_case__	)
  
         self.assertListEqual(snake_case__   ,       snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		List[Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         self.assertListEqual(
             processor.model_input_names   ,       feature_extractor.model_input_names   ,       msg='`processor` and `feature_extractor` model input names do not match'   ,       )
  