PREScode
/
uc-modern-cpp-student
Not watched
1
0
Fork 0
Code
Releases 0 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 481bd3b4c2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '481bd3b4c2'
${ noResults }
uc-modern-cpp-student/frontend/uct/test/04_2layers_test.py

144 lines
6.3 kB
Raw Blame History 

  1. import uctc.nn as nn

  2. import std_model as stdnn

  3. import numpy as np

  4. np.random.seed(42)

  5. class LinearTestModel:

  6.     def __init__(self, input_features, hidden_features, output_features):

  7.         self.w1 = nn.Parameter([input_features, hidden_features])

  8.         self.b1 = nn.Parameter([1, hidden_features])

  9.         self.w2 = nn.Parameter([hidden_features, output_features])

  10.         self.b2 = nn.Parameter([1, output_features])

  11.     

  12.     def forward(self, x):

  13.         l1 = nn.Linear(x, self.w1)

  14.         l2 = nn.AddBias(l1, self.b1)

  15.         l3 = nn.ReLU(l2)

  16.         l4 = nn.Linear(l3, self.w2)

  17.         l5 = nn.AddBias(l4, self.b2)

  18.         return l5

  19.     

  20.     def get_loss(self, x, y):

  21.         return nn.SquareLoss(self.forward(x), y)

  22.     

  23.     def backward(self, x, y):

  24.         loss = self.get_loss(x, y)

  25.         g_w1, g_b1, g_w2, g_b2 = nn.gradients(loss, [self.w1, self.b1, self.w2, self.b2])

  26.         return g_w1.data(), g_b1.data(), g_w2.data(), g_b2.data()

  27.     

  28.     def update(self, x, y, lr):

  29.         loss = self.get_loss(x, y)

  30.         g_w1, g_b1, g_w2, g_b2 = nn.gradients(loss, [self.w1, self.b1, self.w2, self.b2])

  31.         self.w1.update(g_w1, lr)

  32.         self.b1.update(g_b1, lr)

  33.         self.w2.update(g_w2, lr)

  34.         self.b2.update(g_b2, lr)

  35.         print(g_w1.data())

  36.         print(g_b1.data())

  37.         print(g_w2.data())

  38.         print(g_b2.data())

  39.         return self.w1.data(), self.b1.data(), self.w2.data(), self.b2.data()

  40. 

  41. 

  42. class StdLinerTestModel:

  43.     def __init__(self, input_features, hidden_features, output_features, tmodel: LinearTestModel):

  44.         self.w1 = stdnn.Parameter(input_features, hidden_features)

  45.         self.b1 = stdnn.Parameter(1, hidden_features)

  46.         self.w2 = stdnn.Parameter(hidden_features, output_features)

  47.         self.b2 = stdnn.Parameter(1, output_features)

  48.         self.w1.data = np.array(tmodel.w1.data()).reshape(input_features, hidden_features)

  49.         self.b1.data = np.array(tmodel.b1.data()).reshape(1, hidden_features)

  50.         self.w2.data = np.array(tmodel.w2.data()).reshape(hidden_features, output_features)

  51.         self.b2.data = np.array(tmodel.b2.data()).reshape(1, output_features)

  52.         

  53. 

  54.     def forward(self, x):

  55.         l1 = stdnn.Linear(x, self.w1)

  56.         l2 = stdnn.AddBias(l1, self.b1)

  57.         l3 = stdnn.ReLU(l2)

  58.         l4 = stdnn.Linear(l3, self.w2)

  59.         l5 = stdnn.AddBias(l4, self.b2)

  60.         return l5

  61.     

  62.     def get_loss(self, x, y):

  63.         return stdnn.SquareLoss(self.forward(x), y)

  64.     

  65.     def backward(self, x, y):

  66.         loss = self.get_loss(x, y)

  67.         g_w1, g_b1, g_w2, g_b2 = stdnn.gradients(loss, [self.w1, self.b1, self.w2, self.b2])

  68.         return g_w1.data.flatten().tolist(), g_b1.data.flatten().tolist(), g_w2.data.flatten().tolist(), g_b2.data.flatten().tolist()

  69.     

  70.     def update(self, x, y, lr):

  71.         loss = self.get_loss(x, y)

  72.         g_w1, g_b1, g_w2, g_b2 = stdnn.gradients(loss, [self.w1, self.b1, self.w2, self.b2])

  73.         self.w1.update(g_w1, -lr)

  74.         self.b1.update(g_b1, -lr)

  75.         self.w2.update(g_w2, -lr)

  76.         self.b2.update(g_b2, -lr)

  77.         return self.w1.data.flatten().tolist(), self.b1.data.flatten().tolist(), self.w2.data.flatten().tolist(), self.b2.data.flatten().tolist()

  78. 

  79. input_features = 1

  80. hidden_features = 50

  81. output_features = 1

  82. batch_size = 10

  83. x = np.array([-5.146528720855713, 4.451905250549316, 0.4736069440841675, -0.09472138434648514, 4.8939385414123535, 5.209676265716553, -5.967447280883789, 2.9363629817962646, -5.525413990020752, 3.315248489379883]).reshape(batch_size, -1)

  84. y = np.array([0.9072322249412537, -0.9662654995918274, 0.45609915256500244, -0.09457980841398239, -0.9835651516914368, -0.8788799047470093, 0.3105180263519287, 0.2037920206785202, 0.6873041391372681, -0.17278438806533813]).reshape(batch_size, -1)

  85. 

  86. model = LinearTestModel(input_features, hidden_features, output_features)

  87. stdmodel = StdLinerTestModel(input_features, hidden_features, output_features, model)

  88. 

  89. test_x = nn.Constant(x)

  90. predict_y = model.forward(test_x).data()

  91. test_y = nn.Constant(y)

  92. loss = model.get_loss(test_x, test_y).data()

  93. g_w1, g_b1, g_w2, g_b2 = model.backward(test_x, test_y)

  94. new_w1, new_b1, new_w2, new_b2 = model.update(test_x, test_y, 0)

  95. 

  96. 

  97. std_test_x = stdnn.Constant(x)

  98. std_predict_y = stdmodel.forward(std_test_x)

  99. std_test_y = stdnn.Constant(y)

  100. std_loss = stdmodel.get_loss(std_test_x, std_test_y)

  101. std_g_w1, std_g_b1, std_g_w2, std_g_b2 = stdmodel.backward(std_test_x, std_test_y)

  102. std_new_w1, std_new_b1, std_new_w2, std_new_b2 = stdmodel.update(std_test_x, std_test_y, 0)

  103. 

  104. # print(predict_y)

  105. # print()

  106. # print(std_predict_y.data.flatten().tolist())

  107. # check forward

  108. for x, y in zip(predict_y, std_predict_y.data.flatten().tolist()):

  109.     if (abs(x-y) > 1e-4):

  110.         assert 0, "Forward data mismatch!"

  111. 

  112. # print(loss, std_loss.data)

  113. # check loss

  114. if abs(loss[0] - std_loss.data) > 1e-4:

  115.     assert 0, "Loss mismatch!"

  116. 

  117. # check backward

  118. for i, (x, y) in enumerate(zip(g_w1, std_g_w1)):

  119.     if (abs(x-y) > 1e-4):

  120.         assert 0, f"Gradient w1 mismatch at position {i}, g_w1 is {x} while std g_w1 is {y}"

  121. for i, (x, y) in enumerate(zip(g_b1, std_g_b1)):

  122.     if (abs(x-y) > 1e-4):

  123.         assert 0, f"Gradient b1 mismatch at position {i}, g_b1 is {x} while std g_b1 is {y}"

  124. for i, (x, y) in enumerate(zip(g_w2, std_g_w2)):

  125.     if (abs(x-y) > 1e-4):

  126.         assert 0, f"Gradient w2 mismatch at position {i}, g_w2 is {x} while std g_w2 is {y}"

  127. for i, (x, y) in enumerate(zip(g_b2, std_g_b2)):

  128.     if (abs(x-y) > 1e-4):

  129.         assert 0, f"Gradient b2 mismatch at position {i}, g_b2 is {x} while std g_b2 is {y}"

  130. 

  131. # check update

  132. for i, (x, y) in enumerate(zip(new_b1, std_new_b1)):

  133.     if (abs(x-y) > 1e-4):

  134.         assert 0, f"Updated b1 mismatch at position {i}, new_b1 is {x} while std new_b1 is {y}"

  135. for i, (x, y) in enumerate(zip(new_w1, std_new_w1)):

  136.     if (abs(x-y) > 1e-4):

  137.         assert 0, f"Updated w1 mismatch at position {i}, new_w1 is {x} while std new_w1 is {y}"

  138. # for i, (x, y) in enumerate(zip(new_b2, std_new_b2)):

  139. #     if (abs(x-y) > 1e-4):

  140. #         assert 0, f"Updated b2 mismatch at position {i}, new_b2 is {x} while std new_b2 is {y}"

  141. # for i, (x, y) in enumerate(zip(new_w2, std_new_w2)):

  142. #     if (abs(x-y) > 1e-4):

  143. #         assert 0, f"Updated w2 mismatch at position {i}, new_w2 is {x} while std new_w2 is {y}"

  144. print("Test passed")