code: 
  
  
  
  import numpy as np
  from matplotlib import pyplot as plt
  
  
  
  
  def     UpperCAmelCase__ (							__snake_case							)   -> int:
    return 1 / (1 + np.exp(-1 * x							))
  
  
  
  class 		_snake_case      :
  
  
  
  
  
   """simple docstring"""
  
  
  
   def __init__(						self	,    a	,    a=None	,    a=None	,    a=False					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    units
     _A           =    None
     _A           =    None
     _A           =    activation
     if learning_rate is None:
       _A           =    0.3
     _A           =    learning_rate
     _A           =    is_input_layer
   def lowercase_		(						self	,    a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    np.asmatrix(np.random.normal(0	,    0.5	,    (self.units, back_units)					)					)
     _A           =    np.asmatrix(np.random.normal(0	,    0.5	,    self.units					)					).T
     if self.activation is None:
       _A           =    sigmoid
   def lowercase_		(						self					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     if self.activation == sigmoid:
       _A           =    np.dot(self.output	,    (1 - self.output).T					)
       _A           =    np.diag(np.diag(a					)					)
     else:
       _A           =    1
     return gradient_activation
   def lowercase_		(						self	,    a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    xdata
     if self.is_input_layer:
       # input layer
       _A           =    xdata
       _A           =    xdata
       return xdata
     else:
       _A           =    np.dot(self.weight	,    self.xdata					) - self.bias
       _A           =    self.activation(self.wx_plus_b					)
       return self.output
  
  
  
   def lowercase_		(						self	,    a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.cal_gradient()  # i * i 维
     _A           =    np.asmatrix(np.dot(gradient.T	,    a					)					)
  
     _A           =    np.asmatrix(self.xdata					)
     _A           =    -1
     _A           =    self.weight
  
     _A           =    np.dot(gradient.T	,    self._gradient_weight.T					)
     _A           =    gradient * self._gradient_bias
     _A           =    np.dot(a	,    self._gradient_x					).T
     # upgrade: the Negative gradient direction
     _A           =    self.weight - self.learn_rate * self.gradient_weight
     _A           =    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					)	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    []
     _A           =    []
     _A           =    plt.figure()
     _A           =    self.fig_loss.add_subplot(1	,    1	,    1					)
   def lowercase_		(						self	,    a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     self.layers.append(a					)
   def lowercase_		(						self					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     for i, layer in enumerate(self.layers[:]					):
       if i < 1:
         _A           =    True
       else:
         layer.initializer(self.layers[i - 1].units					)
   def lowercase_		(						self					)	->							List[str]:
  
  
  
  
     """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 lowercase_		(						self	,    a	,    a	,    a	,    a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    train_round
     _A           =    accuracy
  
     self.ax_loss.hlines(self.accuracy	,    0	,    self.train_round * 1.1					)
  
     _A           =    np.shape(a					)
     for _ in range(a					):
       _A           =    0
       for row in range(x_shape[0]					):
         _A           =    np.asmatrix(xdata[row, :]					).T
         _A           =    np.asmatrix(ydata[row, :]					).T
  
         # forward propagation
         for layer in self.layers:
           _A           =    layer.forward_propagation(_xdata					)
  
         _A    ,   _A           =    self.cal_loss(_ydata	,    _xdata					)
         _A           =    all_loss + loss
  
         # back propagation: the input_layer does not upgrade
         for layer in self.layers[:0:-1]:
           _A           =    layer.back_propagation(a					)
  
       _A           =    all_loss / x_shape[0]
       self.train_mse.append(a					)
  
       self.plot_loss()
  
       if mse < self.accuracy:
         print('''----达到精度----'''					)
         return mse
     return None
   def lowercase_		(						self	,    a	,    a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    np.sum(np.power((ydata - ydata_)	,    2					)					)
     _A           =    2 * (ydata_ - ydata)
     # vector (shape is the same as _ydata.shape)
     return self.loss, self.loss_gradient
  
  
  
   def lowercase_		(						self					)	->							Optional[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__ (							)   -> List[Any]:
    _A           =    np.random.randn(10						,				10							)
    _A           =    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],
        ]							)
    _A           =    BPNN()
    for i in (10, 20, 30, 2):
      model.add_layer(DenseLayer(__snake_case							)							)
    model.build()
    model.summary()
    model.train(xdata=__snake_case						,				ydata=__snake_case						,				train_round=100						,				accuracy=0.01							)
  
  
  if __name__ == "__main__":
      example()
style_context: 
  
  
  
  from ..utils import DummyObject, requires_backends
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)