View difference between Paste ID: xjDJy9kP and xRTk297d

-function  HelonMethod(x0, y0, N)
+import numpy as np
-x0 = 1;
+import csv
-y0 = 2;
+import Circle_data
-N = 100;
+import matplotlib.pyplot as plt
-TOL = 1e-7;
+
-i = 1;
+class Data(): #這個類別協助我們把資料轉成向量以及上好標籤
-fprintf(1, '次數          x_k               y_k            |x_k - y_k|       |x_k - sqrt(2)|    |y_k - sqrt(2)|\n');
+    def __init__(self, x, z):
-fprintf('___________________________________________________________________________________________________________________\n');
+        self.x = self.setX(x)
-    while i <= N
+        self.z = self.setZ(z)
-        x_new = (x0 + y0)/2;
+
-        y_new = (2*x0*y0)/(x0 + y0);
+    def setX(self, x):
-        fprintf('%2d        %10.9f       %10.9f        %10.9f        %10.9f        %10.9f\n', i, x_new, y_new, abs(x_new - y_new), abs(x_new - sqrt(2)), abs(y_new - sqrt(2)));
+        return np.array([x]).T
-        if abs(x_new - y_new) < TOL
+
-            break
+    def setZ(self, z):
-        end
+        return np.array([z]).T
-        x0 = x_new;
+
-        y0 = y_new;
+def readData(): #這個函數用來讀取資料
-        i = i +1;
+    data = []
-    end
+    with open("output.csv", newline = "") as csvfile:
-end
+        rows = csv.DictReader(csvfile)
         for row in rows:
             x = [float(row['x1']), float(row['x2'])]
             z = [float(row['z'])]
             data.append(Data(x, z))
     return data
 
 def f(x, function_name = 'ReLU'):
     if function_name == 'ReLU':
         return np.maximum(x, 0)
     elif function_name == 'tanh':
         return np.tanh(x)
     elif function_name == 'sigmoid':
         return 1 / (1 + np.exp(-x))
 
 def df(x, Hidden_nodes, function_name = 'ReLU'):
     if function_name == 'ReLU':
         return np.eye(Hidden_nodes, dtype = 'float')*(np.where(x > 0, 1, 0))
     elif function_name == 'tanh':
         return np.eye(Hidden_nodes, dtype = 'float')*(1 - f(x, function_name)*f(x, function_name))
     elif function_name == 'sigmoid':
         return np.eye(Hidden_nodes, dtype = 'float')*(f(x, function_name)*(1 - f(x, function_name)))
 
 def loss(N, Layer, data, loss_name ='MSE'):
     if loss_name == 'MSE':
         result = 0
         for i in range(N):
             result = result + (Layer[2][i] - data[i].z)**2
         return result / (2*N)
 
 def forward(W1, W2, b, N, data, function_name = 'ReLU'): #向前傳播
     Layer1_1 = []
     Layer1_2 = []
     output = []
     Layer = []
     for i in range(N):
         Layer1_1.append(W1.dot(data[i].x)+b)  #計算每一層的值，並存取下來
         Layer1_2.append(f(Layer1_1[i], function_name))
         output.append(W2.dot(Layer1_2[i]))
     Layer.append(Layer1_1)
     Layer.append(Layer1_2)
     Layer.append(output)
     return Layer
 
 def backward(W2, N, Layer, data, Hidden_nodes, function_name = 'ReLU'): #反向傳播
     dW2 = np.zeros((1, Hidden_nodes)) #計算W2的梯度
     for i in range(N):
         dW2 = dW2 + (Layer[2][i] - data[i].z)*(Layer[1][i].T)
     dW2 = dW2 / N
 
     dW1 = np.zeros((Hidden_nodes, 2)) #計算W1和b的梯度
     db = np.zeros((Hidden_nodes, 1))
     for i in range(N):
         temp = (Layer[2][i] - data[i].z)*W2.dot(df(Layer[0][i], Hidden_nodes, function_name))
         db = db + temp.T
         dW1 = dW1 + np.kron(temp.T, data[i].x.T)
     dW1 = dW1 / N
     db = db / N
     return dW1, dW2, db
 
 def Train(W1, W2, b, data, Hidden_nodes, N, learning_rate = 0.3, beta = 0.1, gamma = 0.9, beta1 = 0.9, beta2 = 0.999, Method = 'Adam', function_name = 'ReLU', loss_name ='MSE', train_size = 20000):
     TOL=1e-7
     k = 1
     Layer = forward(W1, W2, b, N, data)
     best_result = 0
     mW1 = sW1 = vW1 = np.zeros(W1.shape)
     mW2 = sW2 = vW2 = np.zeros(W2.shape)
     mb = sb = vb = np.zeros(b.shape)
     train = []
     test = []
     G = [[], [], []]
     dG = [np.zeros(W1.shape), np.zeros(W2.shape), np.zeros(b.shape)]
     y = []
     for i in range(train_size):
         train.append(data[i])
     for i in range(N-train_size):
         test.append(data[train_size+i])
     Layer = forward(W1, W2, b, train_size, data, function_name = 'ReLU')
     while k <= 200:
         dW1, dW2, db = backward(W2, train_size, Layer, train, Hidden_nodes, function_name = 'ReLU')
         if Method == 'GradientDescent':
             W1 = W1 - learning_rate*dW1
             W2 = W2 - learning_rate*dW2
             b = b - learning_rate*db
         elif Method == 'Momentum':
             mW1 = beta*dW1 + gamma*mW1
             mW2 = beta*dW2 + gamma*mW2
             mb = beta*db + gamma*mb
             W1 = W1 - learning_rate*mW1
             W2 = W2 - learning_rate*mW2
             b = b - learning_rate*mb
         elif Method == 'Adagrad':
             G[0].append(dW1)
             G[1].append(dW2)
             G[2].append(db)
             for i in range(k):
                 dG[0] += G[0][i]**2
                 dG[1] += G[1][i]**2
                 dG[2] += G[2][i]**2
             dG[0] = dG[0]**(1/2)
             dG[1] = dG[1]**(1/2)
             dG[2] = dG[2]**(1/2)
             W1 = W1 - (learning_rate/(dG[0] + TOL))*dW1
             W2 = W2 - (learning_rate/(dG[1] + TOL))*dW2
             b = b - (learning_rate/(dG[2] + TOL))*db
         elif Method == 'RMSProp':
             G[0].append(dW1)
             G[1].append(dW2)
             G[2].append(db)
             for i in range(k):
                 dG[0] += G[0][i]**2
                 dG[1] += G[1][i]**2
                 dG[2] += G[2][i]**2
             dG[0] = (1/k)*dG[0]
             dG[1] = (1/k)*dG[1]
             dG[2] = (1/k)*dG[2]
             dG[0] = dG[0]**(1/2)
             dG[1] = dG[1]**(1/2)
             dG[2] = dG[2]**(1/2)
             W1 = W1 - (learning_rate/(dG[0] + TOL))*dW1
             W2 = W2 - (learning_rate/(dG[1] + TOL))*dW2
             b = b - (learning_rate/(dG[2] + TOL))*db
 
         elif Method == 'Adam':
             vW1 = beta1*vW1 + (1 - beta1)*dW1
             vW2 = beta1*vW2 + (1 - beta1)*dW2
             vb = beta1*vb + (1 - beta1)*db
             sW1 = beta2*sW1 + (1 - beta2)*dW1*dW1
             sW2 = beta2*sW2 + (1 - beta2)*dW2*dW2
             sb = beta2*sb + (1 - beta2)*db*db
             vW1_hat = vW1/(1 - beta1**k)
             vW2_hat = vW2/(1 - beta1**k)
             vb_hat = vb/(1 - beta1**k)
             sW1_hat = sW1/(1 - beta2**k)
             sW2_hat = sW2/(1 - beta2**k)
             sb_hat = sb/(1 - beta2**k)
             new_dW1 = learning_rate*vW1_hat/(np.sqrt(sW1_hat)+TOL)
             new_dW2 = learning_rate*vW2_hat/(np.sqrt(sW2_hat)+TOL)
             new_db = learning_rate*vb_hat/(np.sqrt(sb_hat)+TOL)
             W1 = W1 - new_dW1
             W2 = W2 - new_dW2
             b = b - new_db
         Layer = forward(W1, W2, b, train_size, train, function_name = 'ReLU')
         result = ANN(W1, W2, b, test, function_name = 'ReLU')
         y.append(float(loss(train_size, Layer, train, loss_name ='MSE')))
         print(k)
         print(y[k-1])
         if result[1] > best_result:
             best_result = result[1]
             bestW1 = W1
             bestW2 = W2
             bestb = b
         k = k + 1
     return bestW1, bestW2, bestb, y
 
 def ANN(W1, W2, b, data, function_name = 'ReLU'):
     M = len(data)
     output = forward(W1, W2, b, M, data, function_name)
     ans = []
     correct = 0
     for i in range(M):
         if output[2][i] < 0:
             ans.append(-1)
         else:
             ans.append(1)
 
         if ans[i] == data[i].z:
             correct = correct + 1
     return [ans, correct / M]
 
 def GenerateWeight(Hidden_nodes):
     W1 = np.random.rand(Hidden_nodes, 2) #權重矩陣W1和W2
     W2 = np.random.rand(1,Hidden_nodes)
     b = np.random.rand(Hidden_nodes,1) #偏置向量b
     return W1, W2, b
 
 def GenerateTestData(M):
     temp = []
     test_data = []
     for i in range(M):
         r = np.random.randint(0, 2)
         if r == 1:
             temp.append(Circle_data.Data("blue"))
         else:
             temp.append(Circle_data.Data("red"))
         test_data.append(Data(temp[i].x, temp[i].z))
     return test_data
 
 def main():
     data = readData() #把資料讀進來
     N = len(data)  #取得資料的個數
     Hidden_nodes = 4
     t = np.arange(100)
     """
     learning_rate = 0.3
     beta = 0.1
     gamma = 0.9
     beta1 = 0.9
     beta2 = 0.999
     Method = 'Adam'
     function_name = 'ReLU'
     loss_name ='MSE'
     train_size = 20000
     """
     W1, W2, b = GenerateWeight(Hidden_nodes)
     W1_1, W2_1, b_1, y_1 = Train(W1, W2, b, data, Hidden_nodes, N, learning_rate = 0.01, Method = 'GradientDescent')
     W1_2, W2_2, b_2, y_2 = Train(W1, W2, b, data, Hidden_nodes, N, learning_rate = 0.01, Method = 'Momentum')
     W1_3, W2_3, b_3, y_3 = Train(W1, W2, b, data, Hidden_nodes, N, learning_rate = 0.01, Method = 'Adagrad')
     W1_4, W2_4, b_4, y_4 = Train(W1, W2, b, data, Hidden_nodes, N, learning_rate = 0.01, Method = 'RMSProp')
     W1_5, W2_5, b_5, y_5 = Train(W1, W2, b, data, Hidden_nodes, N, learning_rate = 0.01, Method = 'Adam')
 
     plt.plot(t, y_1, 'b-', t, y_2, 'r-', t, y_3, 'g-', t, y_4, 'k-', t, y_5, 'y-')
     plt.show()
     plt.savefig('plot1.png')
 
     M = 1000
     test_data = GenerateTestData(M)
 
     result = ANN(W1_1, W2_1, b_1, test_data)
     print("命中率=",100*result[1],'%')
     result = ANN(W1_2, W2_2, b_2, test_data)
     print("命中率=",100*result[1],'%')
     result = ANN(W1_3, W2_3, b_3, test_data)
     print("命中率=",100*result[1],'%')
     result = ANN(W1_4, W2_4, b_4, test_data)
     print("命中率=",100*result[1],'%')
     result = ANN(W1_5, W2_5, b_5, test_data)
     print("命中率=",100*result[1],'%')
 
 
 if __name__ == "__main__":
     main()