text: import re
  from matplotlib import pyplot as plt
  import numpy as np
  from numpy import dot, tanh
  import torch
  import torch.nn as nn
  from torch.autograd import Variable
  
  hidden_layer1_linear_trans = np.genfromtxt("hidden1_weight.txt")
  hidden_layer2_linear_trans = np.genfromtxt("hidden2_weight.txt")
  output_layer_linear_trans = np.genfromtxt("out_weight.txt")
  anwser = np.genfromtxt("value_list.txt")
  
  def test(model, figure_data, target):
      """ 
      a function used to test the accuracy of neural network.
  
      Args:
          model (class): a neural network
          test_data (iterator): test datas
          epoch_num (int): repeat number of datasets used to train
          writer (tensorboard): write log file for data visition
          decimal_number (int): the significant number of weights
      """
      correct = 0
      with torch.no_grad():
          t_data = torch.Tensor(figure_data)
          target = torch.as_tensor(target)
          t_data = t_data.view(t_data.size(1), -1)
          t_data_binary = np.ceil(t_data.numpy())
          t_data = torch.from_numpy(t_data_binary)
          t_data, target = Variable(t_data), Variable(target)
          output = model(t_data)
          pred = output.max(1, keepdim=True)[1] 
          correct += pred.eq(target.view_as(pred)).sum().item()
          if correct > 0:
              print('right')
              return True
          else:
              print('wrong')
              return False
  
  class Net(nn.Module):
  
      def __init__(self, n_feature, n_hidden1, n_hidden2, n_output):
          super(Net, self).__init__()
          self.hidden1 = nn.Linear(n_feature, n_hidden1, bias=False)
          self.hidden2 = nn.Linear(n_hidden1, n_hidden2, bias=False)
          self.out = nn.Linear(n_hidden2, n_output, bias=False)
  
      # connect inputs and outputs
      def forward(self, x):
          # print(f'input: {x}')
          x = torch.tanh(self.hidden1(x))
          # print(f'hidden1 output: {x}')
          x = torch.tanh(self.hidden2(x))
          x = torch.tanh(self.out(x))
          return x
  
  
  size_inputs = 16*16
  size_hidden1 = 32
  size_hidden2 = 32
  size_outputs = 10
  
  device = "cuda" if torch.cuda.is_available() else "cpu"
  device = 'cpu'  # in MNIST recognition 'GPu' is slower than 'cpu'
  print(f"Using {device} device")
  
  # create a network sample
  net = Net(n_feature=size_inputs, n_hidden1=size_hidden1, n_hidden2=size_hidden2, n_output=size_outputs).to(device)
  net = torch.load(f'weight_data\epoch_20')
  # hidden_layer1_linear_trans = net.state_dict()['hidden1.weight'].numpy()
  # hidden_layer2_linear_trans = net.state_dict()['hidden2.weight'].numpy()
  # output_layer_linear_trans = net.state_dict()['out.weight'].numpy()
  correct_count = 0
  count_pytoch = 0
  
  for i in range(10000):
  
      fig_data = np.genfromtxt("data_figures/fig{}.txt".format(i))
      #fig_data = (fig_data > 0.5) # 二值化
      #plt.imshow(fig_data, cmap='Greys')
      #plt.show()
  
      input_layer = np.ceil(np.reshape(fig_data, (256, 1)))
      # input_layer = torch.Tensor(input_layer)
  
      hidden_layer1_result = dot(hidden_layer1_linear_trans, input_layer)
      hidden_layer1_output = tanh(hidden_layer1_result)
      # print(f'output from non-pytorch: {hidden_layer1_output}')
  
      hidden_layer2_result = dot(hidden_layer2_linear_trans, hidden_layer1_output)
      hidden_layer2_output = tanh(hidden_layer2_result)
  
      output_layer_result = dot(output_layer_linear_trans, hidden_layer2_output)
      output_layer_tanh = tanh(output_layer_result)
      # print(f'input from non-pytorch: {input_layer.T}')
      # print(f'output from non-pytorch: {hidden_layer1_output.T}')
  
      number = np.argmax(output_layer_tanh)
      print(number, int(anwser[i]), end = ' ')
      if number == int(anwser[i]):
          correct_count += 1
          print('T')
      else:
          print('F')
      #print(output_layer_tanh)
      result = test(model=net, figure_data=input_layer, target=anwser[i])
      if result:
          count_pytoch += 1
  
  print(correct_count)
  print(f'correct from pytorch: {count_pytoch}')
  