





import math
import unittest



def A_     (		A__    )  ->		bool:
       assert isinstance(A__		,				A__    ) and (
           number >= 0
       ), "'number' must been an int and positive"

       if 1 < number < 4:
              # 2 and 3 are primes
              return True
       elif number < 2 or number % 2 == 0 or number % 3 == 0:
              # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
              return False

       # All primes number are in format of 6k +/- 1
       for i in range(5		,				int(math.sqrt(A__    ) + 1    )		,				6    ):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True





class 			A__   (							unittest.TestCase     ):




   """simple docstring"""



   def 							__lowercase		( self)      ->						Optional[Any]:







          '''simple docstring'''

          self.assertTrue(is_prime(2))
          self.assertTrue(is_prime(3))
          self.assertTrue(is_prime(5))
          self.assertTrue(is_prime(7))
          self.assertTrue(is_prime(11))
          self.assertTrue(is_prime(13))
          self.assertTrue(is_prime(17))
          self.assertTrue(is_prime(19))
          self.assertTrue(is_prime(23))
          self.assertTrue(is_prime(29))

   def 							__lowercase		( self)      ->						Optional[Any]:







          '''simple docstring'''

          with self.assertRaises(lowercase):
                 is_prime(-19)
          self.assertFalse(
              is_prime(0) ,  'Zero doesn\'t have any positive factors, primes must have exactly two.' ,  )
          self.assertFalse(
              is_prime(1) ,  'One only has 1 positive factor, primes must have exactly two.' ,  )
          self.assertFalse(is_prime(2 * 2))
          self.assertFalse(is_prime(2 * 3))
          self.assertFalse(is_prime(3 * 3))
          self.assertFalse(is_prime(3 * 5))
          self.assertFalse(is_prime(3 * 5 * 7))


if __name__ == "__main__":
    unittest.main()









import pickle

import numpy as np
from matplotlib import pyplot as plt





class 			A__   :




   """simple docstring"""



   def __init__( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase=0.2 ,  lowercase=0.2)      ->						Any:







          '''simple docstring'''

          a__						:     Tuple			=    bp_numa
          a__						:     Union[str, Any]			=    bp_numa
          a__						:     Optional[int]			=    bp_numa
          a__						:     Optional[int]			=    conva_get[:2]
          a__						:     Optional[Any]			=    conva_get[2]
          a__						:     Optional[int]			=    size_pa
          a__						:     Union[str, Any]			=    rate_w
          a__						:     Dict			=    rate_t
          a__						:     int			=    [
              np.mat(-1 * np.random.rand(self.conva[0] ,  self.conva[0]) + 0.5)
              for i in range(self.conva[1])
          ]
          a__						:     Optional[int]			=    np.mat(-1 * np.random.rand(self.num_bpa ,  self.num_bpa) + 0.5)
          a__						:     Optional[int]			=    np.mat(-1 * np.random.rand(self.num_bpa ,  self.num_bpa) + 0.5)
          a__						:     Any			=    -2 * np.random.rand(self.conva[1]) + 1
          a__						:     Optional[Any]			=    -2 * np.random.rand(self.num_bpa) + 1
          a__						:     Optional[int]			=    -2 * np.random.rand(self.num_bpa) + 1

   def 							__lowercase		( self ,  lowercase)      ->						List[Any]:







          '''simple docstring'''

          a__						:     Optional[Any]			=    {
              'num_bp1': self.num_bpa,
              'num_bp2': self.num_bpa,
              'num_bp3': self.num_bpa,
              'conv1': self.conva,
              'step_conv1': self.step_conva,
              'size_pooling1': self.size_poolinga,
              'rate_weight': self.rate_weight,
              'rate_thre': self.rate_thre,
              'w_conv1': self.w_conva,
              'wkj': self.wkj,
              'vji': self.vji,
              'thre_conv1': self.thre_conva,
              'thre_bp2': self.thre_bpa,
              'thre_bp3': self.thre_bpa,
          }
          with open(lowercase ,  'wb') as f:
                 pickle.dump(lowercase ,  lowercase)

          print(F'Model saved： {save_path}')

   @classmethod
   def 							__lowercase		( cls ,  lowercase)      ->						Any:







          '''simple docstring'''

          with open(lowercase ,  'rb') as f:
                 a__						:     Any			=    pickle.load(lowercase)  # noqa: S301

          a__						:     Dict			=    model_dic.get('conv1')
          conv_get.append(model_dic.get('step_conv1'))
          a__						:     Tuple			=    model_dic.get('size_pooling1')
          a__						:     Optional[int]			=    model_dic.get('num_bp1')
          a__						:     Tuple			=    model_dic.get('num_bp2')
          a__						:     Optional[Any]			=    model_dic.get('num_bp3')
          a__						:     Optional[Any]			=    model_dic.get('rate_weight')
          a__						:     int			=    model_dic.get('rate_thre')
          # create model instance
          a__						:     Union[str, Any]			=    CNN(lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase)
          # modify model parameter
          a__						:     str			=    model_dic.get('w_conv1')
          a__						:     Optional[int]			=    model_dic.get('wkj')
          a__						:     Tuple			=    model_dic.get('vji')
          a__						:     str			=    model_dic.get('thre_conv1')
          a__						:     List[str]			=    model_dic.get('thre_bp2')
          a__						:     Tuple			=    model_dic.get('thre_bp3')
          return conv_ins

   def 							__lowercase		( self ,  lowercase)      ->						Any:







          '''simple docstring'''

          return 1 / (1 + np.exp(-1 * x))

   def 							__lowercase		( self ,  lowercase)      ->						Optional[int]:







          '''simple docstring'''

          return round(lowercase ,  3)

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						Any:







          '''simple docstring'''

          a__						:     Union[str, Any]			=    convs[0]
          a__						:     Tuple			=    convs[1]
          a__						:     Any			=    np.shape(lowercase)[0]
          # get the data slice of original image data, data_focus
          a__						:     Tuple			=    []
          for i_focus in range(0 ,  size_data - size_conv + 1 ,  lowercase):
                 for j_focus in range(0 ,  size_data - size_conv + 1 ,  lowercase):
                        a__						:     str			=    data[
                            i_focus : i_focus + size_conv, j_focus : j_focus + size_conv
                        ]
                        data_focus.append(lowercase)
        # calculate the feature map of every single kernel, and saved as list of matrix
          a__						:     str			=    []
          a__						:     Union[str, Any]			=    int((size_data - size_conv) / conv_step + 1)
          for i_map in range(lowercase):
                 a__						:     Tuple			=    []
                 for i_focus in range(len(lowercase)):
                        a__						:     Optional[Any]			=    (
                            np.sum(np.multiply(data_focus[i_focus] ,  w_convs[i_map]))
                            - thre_convs[i_map]
                        )
                        featuremap.append(self.sig(lowercase))
                 a__						:     Dict			=    np.asmatrix(lowercase).reshape(
                     lowercase ,  lowercase)
                 data_featuremap.append(lowercase)

          # expanding the data slice to One dimenssion
          a__						:     int			=    []
          for each_focus in data_focus:
                 focusa_list.extend(self.Expand_Mat(lowercase))
          a__						:     Optional[int]			=    np.asarray(lowercase)
          return focus_list, data_featuremap

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase="average_pool")      ->						str:







          '''simple docstring'''

          a__						:     Any			=    len(featuremaps[0])
          a__						:     int			=    int(size_map / size_pooling)
          a__						:     Optional[Any]			=    []
          for i_map in range(len(lowercase)):
                 a__						:     Any			=    featuremaps[i_map]
                 a__						:     Optional[int]			=    []
                 for i_focus in range(0 ,  lowercase ,  lowercase):
                        for j_focus in range(0 ,  lowercase ,  lowercase):
                               a__						:     Any			=    feature_map[
                                   i_focus : i_focus + size_pooling,
                                   j_focus : j_focus + size_pooling,
                               ]
                               if pooling_type == "average_pool":
                                      # average pooling
                                      map_pooled.append(np.average(lowercase))
                               elif pooling_type == "max_pooling":
                                      # max pooling
                                      map_pooled.append(np.max(lowercase))
                 a__						:     List[str]			=    np.asmatrix(lowercase).reshape(lowercase ,  lowercase)
                 featuremap_pooled.append(lowercase)
          return featuremap_pooled

   def 							__lowercase		( self ,  lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          a__						:     Any			=    []
          for i in range(len(lowercase)):
                 a__						:     Tuple			=    np.shape(data[i])
                 a__						:     List[str]			=    data[i].reshape(1 ,  shapes[0] * shapes[1])
                 a__						:     Optional[Any]			=    data_listed.getA().tolist()[0]
                 data_expanded.extend(lowercase)
          a__						:     Union[str, Any]			=    np.asarray(lowercase)
          return data_expanded

   def 							__lowercase		( self ,  lowercase)      ->						Dict:







          '''simple docstring'''

          a__						:     Dict			=    np.asarray(lowercase)
          a__						:     Optional[int]			=    np.shape(lowercase)
          a__						:     Any			=    data_mat.reshape(1 ,  shapes[0] * shapes[1])
          return data_expanded

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						str:







          '''simple docstring'''

          a__						:     int			=    []
          a__						:     Optional[int]			=    0
          for i_map in range(lowercase):
                 a__						:     Optional[Any]			=    np.ones((size_map, size_map))
                 for i in range(0 ,  lowercase ,  lowercase):
                        for j in range(0 ,  lowercase ,  lowercase):
                               a__						:     Union[str, Any]			=    pd_pool[
                                   i_pool
                               ]
                               a__						:     Tuple			=    i_pool + 1
                 a__						:     Optional[int]			=    np.multiply(
                     lowercase ,  np.multiply(out_map[i_map] ,  (1 - out_map[i_map])))
                 pd_all.append(lowercase)
          return pd_all

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase=bool)      ->						str:







          '''simple docstring'''

          print('----------------------Start Training-------------------------')
          print((' - - Shape: Train_Data  ', np.shape(lowercase)))
          print((' - - Shape: Teach_Data  ', np.shape(lowercase)))
          a__						:     Dict			=    0
          a__						:     List[Any]			=    []
          a__						:     Optional[int]			=    1_0000
          while rp < n_repeat and mse >= error_accuracy:
                 a__						:     Dict			=    0
                 print(F'-------------Learning Time {rp}--------------')
                 for p in range(len(lowercase)):
                        # print('------------Learning Image: %d--------------'%p)
                        a__						:     Dict			=    np.asmatrix(datas_train[p])
                        a__						:     Any			=    np.asarray(datas_teach[p])
                        a__			,							a__						:     Optional[int]			=    self.convolute(
                            lowercase ,  self.conva ,  self.w_conva ,  self.thre_conva ,  conv_step=self.step_conva ,  )
                        a__						:     Dict			=    self.pooling(lowercase ,  self.size_poolinga)
                        a__						:     Optional[Any]			=    np.shape(lowercase)
                        a__						:     Union[str, Any]			=    self._expand(lowercase)
                        a__						:     List[Any]			=    data_bp_input

                        a__						:     Tuple			=    np.dot(lowercase ,  self.vji.T) - self.thre_bpa
                        a__						:     Any			=    self.sig(lowercase)
                        a__						:     Any			=    np.dot(lowercase ,  self.wkj.T) - self.thre_bpa
                        a__						:     Any			=    self.sig(lowercase)

                        # --------------Model Leaning ------------------------
                        # calculate error and gradient---------------
                        a__						:     Any			=    np.multiply(
                            (data_teach - bp_outa) ,  np.multiply(lowercase ,  (1 - bp_outa)))
                        a__						:     Optional[Any]			=    np.multiply(
                            np.dot(lowercase ,  self.wkj) ,  np.multiply(lowercase ,  (1 - bp_outa)))
                        a__						:     Tuple			=    np.dot(lowercase ,  self.vji)

                        a__						:     Union[str, Any]			=    pd_i_all / (self.size_poolinga * self.size_poolinga)
                        a__						:     List[str]			=    pd_conva_pooled.T.getA().tolist()
                        a__						:     str			=    self._calculate_gradient_from_pool(
                            lowercase ,  lowercase ,  shape_featuremapa[0] ,  shape_featuremapa[1] ,  self.size_poolinga ,  )
                        # weight and threshold learning process---------
                        # convolution layer
                        for k_conv in range(self.conva[1]):
                               a__						:     Optional[int]			=    self._expand_mat(pd_conva_all[k_conv])
                               a__						:     int			=    self.rate_weight * np.dot(lowercase ,  lowercase)

                               a__						:     List[str]			=    self.w_conva[k_conv] + delta_w.reshape(
                                   (self.conva[0], self.conva[0]))

                               a__						:     str			=    (
                                   self.thre_conva[k_conv]
                                   - np.sum(pd_conva_all[k_conv]) * self.rate_thre
                               )
                        # all connected layer
                        a__						:     List[str]			=    self.wkj + pd_k_all.T * bp_outa * self.rate_weight
                        a__						:     List[str]			=    self.vji + pd_j_all.T * bp_outa * self.rate_weight
                        a__						:     Tuple			=    self.thre_bpa - pd_k_all * self.rate_thre
                        a__						:     Tuple			=    self.thre_bpa - pd_j_all * self.rate_thre
                        # calculate the sum error of all single image
                        a__						:     List[str]			=    np.sum(abs(data_teach - bp_outa))
                        error_count += errors
                        # print('   ----Teach      ',data_teach)
                        # print('   ----BP_output  ',bp_out3)
                 a__						:     Any			=    rp + 1
                 a__						:     Optional[Any]			=    error_count / patterns
                 all_mse.append(lowercase)

          def draw_error():
                 a__						:     int			=    [error_accuracy for i in range(int(n_repeat * 1.2))]
                 plt.plot(lowercase ,  '+-')
                 plt.plot(lowercase ,  'r--')
                 plt.xlabel('Learning Times')
                 plt.ylabel('All_mse')
                 plt.grid(lowercase ,  alpha=0.5)
                 plt.show()

          print('------------------Training Complished---------------------')
          print((' - - Training epoch: ', rp, F'     - - Mse: {mse:.6f}'))
          if draw_e:
                 draw_error()
          return mse

   def 							__lowercase		( self ,  lowercase)      ->						Optional[int]:







          '''simple docstring'''

          a__						:     str			=    []
          print('-------------------Start Testing-------------------------')
          print((' - - Shape: Test_Data  ', np.shape(lowercase)))
          for p in range(len(lowercase)):
                 a__						:     int			=    np.asmatrix(datas_test[p])
                 a__			,							a__						:     Optional[int]			=    self.convolute(
                     lowercase ,  self.conva ,  self.w_conva ,  self.thre_conva ,  conv_step=self.step_conva ,  )
                 a__						:     str			=    self.pooling(lowercase ,  self.size_poolinga)
                 a__						:     Optional[int]			=    self._expand(lowercase)

                 a__						:     str			=    data_bp_input
                 a__						:     Union[str, Any]			=    bp_outa * self.vji.T - self.thre_bpa
                 a__						:     Optional[Any]			=    self.sig(lowercase)
                 a__						:     int			=    bp_outa * self.wkj.T - self.thre_bpa
                 a__						:     Dict			=    self.sig(lowercase)
                 produce_out.extend(bp_outa.getA().tolist())
          a__						:     List[Any]			=    [list(map(self.do_round ,  lowercase)) for each in produce_out]
          return np.asarray(lowercase)

   def 							__lowercase		( self ,  lowercase)      ->						str:







          '''simple docstring'''

          a__						:     str			=    np.asmatrix(lowercase)
          a__			,							a__						:     str			=    self.convolute(
              lowercase ,  self.conva ,  self.w_conva ,  self.thre_conva ,  conv_step=self.step_conva ,  )
          a__						:     List[str]			=    self.pooling(lowercase ,  self.size_poolinga)

          return data_conveda, data_pooleda


if __name__ == "__main__":
    pass


