
"""simple docstring"""
import pickle

import numpy as np
from matplotlib import pyplot as plt
class 			UpperCamelCase      :
     def __init__(     self  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__=0.2  ,     snake_case__=0.2				):




       """simple docstring"""


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




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Optional[int]         = {
           "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(_lowerCamelCase  ,     "wb"				) as f:
         pickle.dump(_lowerCamelCase  ,     _lowerCamelCase				)

       print(F'''Model saved： {save_path}'''				)
     @classmethod
     def 				__SCREAMING_SNAKE_CASE							(     cls  ,     snake_case__				):




       """simple docstring"""


       with open(_lowerCamelCase  ,     "rb"				) as f:
         _SCREAMING_SNAKE_CASE   :				Tuple         = pickle.load(_lowerCamelCase				)  # noqa: S301

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




       """simple docstring"""


       return 1 / (1 + np.exp(-1 * x				))
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__				):




       """simple docstring"""


       return round(_lowerCamelCase  ,     3				)
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__				):




       """simple docstring"""


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

       # expanding the data slice to One dimenssion
       _SCREAMING_SNAKE_CASE   :				List[str]         = []
       for each_focus in data_focus:
         focusa_list.extend(self.Expand_Mat(_lowerCamelCase				)				)
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]         = np.asarray(_lowerCamelCase				)
       return focus_list, data_featuremap
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__  ,     snake_case__="average_pool"				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Optional[Any]         = len(featuremaps[0]				)
       _SCREAMING_SNAKE_CASE   :				List[Any]         = int(size_map / size_pooling				)
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]         = []
       for i_map in range(len(_lowerCamelCase				)				):
         _SCREAMING_SNAKE_CASE   :				List[str]         = featuremaps[i_map]
         _SCREAMING_SNAKE_CASE   :				int         = []
         for i_focus in range(0  ,     _lowerCamelCase  ,     _lowerCamelCase				):
           for j_focus in range(0  ,     _lowerCamelCase  ,     _lowerCamelCase				):
             _SCREAMING_SNAKE_CASE   :				Union[str, 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(_lowerCamelCase				)				)
             elif pooling_type == "max_pooling":
               # max pooling
               map_pooled.append(np.max(_lowerCamelCase				)				)
         _SCREAMING_SNAKE_CASE   :				str         = np.asmatrix(_lowerCamelCase				).reshape(_lowerCamelCase  ,     _lowerCamelCase				)
         featuremap_pooled.append(_lowerCamelCase				)
       return featuremap_pooled
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				List[Any]         = []
       for i in range(len(_lowerCamelCase				)				):
         _SCREAMING_SNAKE_CASE   :				Union[str, Any]         = np.shape(data[i]				)
         _SCREAMING_SNAKE_CASE   :				Any         = data[i].reshape(1  ,     shapes[0] * shapes[1]				)
         _SCREAMING_SNAKE_CASE   :				Any         = data_listed.getA().tolist()[0]
         data_expanded.extend(_lowerCamelCase				)
       _SCREAMING_SNAKE_CASE   :				Dict         = np.asarray(_lowerCamelCase				)
       return data_expanded
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				int         = np.asarray(_lowerCamelCase				)
       _SCREAMING_SNAKE_CASE   :				str         = np.shape(_lowerCamelCase				)
       _SCREAMING_SNAKE_CASE   :				int         = data_mat.reshape(1  ,     shapes[0] * shapes[1]				)
       return data_expanded
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Any         = []
       _SCREAMING_SNAKE_CASE   :				Dict         = 0
       for i_map in range(_lowerCamelCase				):
         _SCREAMING_SNAKE_CASE   :				Union[str, Any]         = np.ones((size_map, size_map)				)
         for i in range(0  ,     _lowerCamelCase  ,     _lowerCamelCase				):
           for j in range(0  ,     _lowerCamelCase  ,     _lowerCamelCase				):
             _SCREAMING_SNAKE_CASE   :				Tuple         = pd_pool[
                 i_pool
             ]
             _SCREAMING_SNAKE_CASE   :				Any         = i_pool + 1
         _SCREAMING_SNAKE_CASE   :				Union[str, Any]         = np.multiply(
             _lowerCamelCase  ,     np.multiply(out_map[i_map]  ,     (1 - out_map[i_map])				)				)
         pd_all.append(_lowerCamelCase				)
       return pd_all
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__  ,     snake_case__=bool				):




       """simple docstring"""


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

           _SCREAMING_SNAKE_CASE   :				int         = np.dot(_lowerCamelCase  ,     self.vji.T				) - self.thre_bpa
           _SCREAMING_SNAKE_CASE   :				Any         = self.sig(_lowerCamelCase				)
           _SCREAMING_SNAKE_CASE   :				int         = np.dot(_lowerCamelCase  ,     self.wkj.T				) - self.thre_bpa
           _SCREAMING_SNAKE_CASE   :				int         = self.sig(_lowerCamelCase				)

           # --------------Model Leaning ------------------------
           # calculate error and gradient---------------
           _SCREAMING_SNAKE_CASE   :				int         = np.multiply(
               (data_teach - bp_outa)  ,     np.multiply(_lowerCamelCase  ,     (1 - bp_outa)				)				)
           _SCREAMING_SNAKE_CASE   :				Optional[int]         = np.multiply(
               np.dot(_lowerCamelCase  ,     self.wkj				)  ,     np.multiply(_lowerCamelCase  ,     (1 - bp_outa)				)				)
           _SCREAMING_SNAKE_CASE   :				str         = np.dot(_lowerCamelCase  ,     self.vji				)

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

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

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

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

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




       """simple docstring"""


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

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




     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Dict         = np.asmatrix(_lowerCamelCase				)
       _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				Optional[int]         = self.convolute(
           _lowerCamelCase  ,     self.conva  ,     self.w_conva  ,     self.thre_conva  ,     conv_step=self.step_conva  ,     )
       _SCREAMING_SNAKE_CASE   :				Tuple         = self.pooling(_lowerCamelCase  ,     self.size_poolinga				)

       return data_conveda, data_pooleda


if __name__ == "__main__":
      pass





"""simple docstring"""
import operator as op





def    _lowerCAmelCase    (     lowerCamelCase__							:							Tuple				)  ->    List[str]:
  _SCREAMING_SNAKE_CASE   :				Optional[int]							    = []
  _SCREAMING_SNAKE_CASE   :				str							    = lambda lowerCamelCase__,						lowerCamelCase__				: int(x / y				)  # noqa: E731 integer division operation
  _SCREAMING_SNAKE_CASE   :				Any							    = {
      "^": op.pow,
      "*": op.mul,
      "/": div,
      "+": op.add,
      "-": op.sub,
  }  # operators & their respective operation

  # print table header
  print("Symbol".center(8				),						"Action".center(1_2				),						"Stack",						sep=" | "				)
  print("-" * (3_0 + len(lowerCamelCase__				))				)

  for x in post_fix:
    if x.isdigit():  # if x in digit
      stack.append(lowerCamelCase__				)  # append x to stack
      # output in tabular format
      print(x.rjust(8				),						("push(" + x + ")").ljust(1_2				),						",".join(lowerCamelCase__				),						sep=" | "				)
    else:
      _SCREAMING_SNAKE_CASE   :				Dict							    = stack.pop()  # pop stack
      # output in tabular format
      print("".rjust(8				),						("pop(" + b + ")").ljust(1_2				),						",".join(lowerCamelCase__				),						sep=" | "				)

      _SCREAMING_SNAKE_CASE   :				Any							    = stack.pop()  # pop stack
      # output in tabular format
      print("".rjust(8				),						("pop(" + a + ")").ljust(1_2				),						",".join(lowerCamelCase__				),						sep=" | "				)

      stack.append(
          str(opr[x](int(lowerCamelCase__				),						int(lowerCamelCase__				)				)				)				)  # evaluate the 2 values popped from stack & push result to stack
      # output in tabular format
      print(
          x.rjust(8				),						("push(" + a + x + b + ")").ljust(1_2				),						",".join(lowerCamelCase__				),						sep=" | ",						)

  return int(stack[0]				)


if __name__ == "__main__":
      lowercase_       :						int     					=	input('''\n\nEnter a Postfix Equation (space separated) = ''').split(''' ''')
      print('''\n\tResult = ''', solve(Postfix))



