def construct_model(self, x_train, y_train): # get number of features input_dim = x_train.shape[-1] # get number of classes output_dim = len(np.unique(y_train)) layer_num = len(self.hidden_layer_sizes) hidden_layer_num = self.hidden_layer_sizes batch_size = self.batch_size _lambda = self._lambda if batch_size == 'auto': # use all data batch_size = x_train.shape[0] self.input = lfdnn.tensor([batch_size, input_dim], 'input') self.label = lfdnn.tensor([batch_size, output_dim], 'label') h = self.input # put your construction code here, feel free to modify the assignment of `w` # Hint: you should put all weight and bias variables into self.weight w = lfdnn.tensor([input_dim, output_dim], 'output_weight') # end of your construction code self.weight['output_weight'] = w b = lfdnn.tensor([1, output_dim], 'output_bias') self.weight['output_bias'] = b h = operator.add(operator.matmul(h, w), b) self.output = operator.softmax(h) self.loss = operator.CE_with_logit(h, self.label) if _lambda > 0: for k, v in self.weight.items(): if k.find('bias') > 0: continue regularization_term = operator.scale(operator.mean_square_sum(v), _lambda) self.loss = operator.add(self.loss, regularization_term) self.accuracy = operator.accuracy(self.output, self.label)
def test_constant_tensor_derivative(self): a = tensor([2, 2], 'a', value=3) b = tensor([2, 2], 'b') feed = {'b': np.array([[5, 6], [7, 8]])} assert_array_almost_equal( operator.reduce_sum(operator.product(a, b)).differentiate(b, feed), 3 * np.ones([2, 2]))
def construct_model(self, x_train, y_train): # get number of features input_dim = x_train.shape[-1] # get number of classes output_dim = 1 batch_size = self.batch_size _lambda = self.alpha if batch_size == 'auto': # use all data batch_size = x_train.shape[0] self.input = lfdnn.tensor([batch_size, input_dim], 'input') self.label = lfdnn.tensor([batch_size, output_dim], 'label') w = lfdnn.tensor([input_dim, output_dim], 'output_weight') self.weight['output_weight'] = w b = lfdnn.tensor([1, output_dim], 'output_bias') self.weight['output_bias'] = b # put your code here, you can adjust the following lines h = self.input h = operator.add(operator.matmul(h, w), b) self.output = h self.loss = operator.mse(h, self.label) # end of your modification # dummy acc self.accuracy = self.loss
def test_mse(self): a = tensor([3, 1], 'a') b = tensor([3, 1], 'b') feed = { 'a': np.array([[1.3], [-2.2], [0.4]]), 'b': np.array([[1.2], [-2.3], [0.2]]) } true_value = mean_squared_error(feed['a'], feed['b']) self.assertAlmostEqual(operator.mse(a, b).eval(feed), true_value)
def test_cross_entropy(self): x = tensor([3, 3], 'x') y = tensor([3, 3], 'y') feed = { 'x': np.array([[0.4, 0.5, 0.1], [0.4, 0.5, 0.1], [0.4, 0.5, 0.1]]), 'y': np.array([[0, 0, 1], [0, 0, 1], [1, 0, 0]]) } true_value = (2 * np.log(0.1) + np.log(0.4)) / 3 self.assertAlmostEqual(operator.CE(x, y).eval(feed), -1.0 * true_value)
def test_matrix_multiplication(self): a = tensor([2, 3], 'a') b = tensor([3, 1], 'b') feed = { 'a': np.array([[0.4, 0.5, 1.1], [0.1, 2.3, -0.3]]), 'b': np.array([[1.2], [-2.3], [0.2]]) } true_matrix = np.array([[-0.45], [-5.23]]) assert_array_almost_equal( operator.matmul(a, b).eval(feed), true_matrix)
def test_backward_add(self): a = tensor([1, 1], 'a') feed = {'a': np.array([[0.1]])} target = operator.add(operator.product(a, a), operator.scale(a, 3)) self.assertAlmostEqual(target.eval(feed)[0, 0], 0.31) self.assertAlmostEqual( operator.reduce_sum(target).differentiate(a, feed)[0, 0], 3.2)
def test_softmax(self): a = tensor([1, 3], 'a') feed = {'a': np.array([[1, 2, 3]])} answer_list = np.exp([1, 2, 3]) answer_list /= np.sum(answer_list) assert_array_almost_equal( operator.softmax(a).forward(feed)[0], answer_list)
def test_relu_derivative(self): a = tensor([1, 3], 'a') feed = {'a': np.array([[-1, 0, 3]])} assert_array_almost_equal( operator.relu(a).differentiate(a, feed), np.array([[0, 0, 1]])) result_1 = operator.relu(operator.sigmoid(a)).differentiate(a, feed) result_2 = operator.sigmoid(a).differentiate(a, feed) assert_array_almost_equal(result_1, result_2)
def test_abs(self): a = tensor([1, 3], 'a') feed = {'a': np.array([[1, -1, 3]])} assert_array_almost_equal( operator.abs(a).forward(feed), np.array([[1, 1, 3]])) result_1 = operator.abs(operator.scale(a, 2)).differentiate(a, feed) result_2 = 2 * np.array([[1, -1, 1]]) assert_array_almost_equal(result_1, result_2)
def test_backward(self): a = tensor([1, 1], 'a') feed = {'a': np.array([[0]])} self.assertAlmostEqual( operator.sigmoid(a).differentiate(a, feed)[0, 0], 0.25)
def test_product(self): a = tensor([2, 1], 'a') feed = {'a': np.array([[5], [6]])} assert_array_almost_equal( operator.product(a, a).eval(feed), np.array([[25], [36]]))
def test_forward(self): a = tensor([2], 'a') feed = {'a': np.array([5, 6])} self.assertAlmostEqual(operator.reduce_mean(a).forward(feed), 5.5)
def test_shape(self): a = tensor([1, 2], 'a') self.assertEqual(operator.reduce_mean(a).shape, [1, 1])
def test_relu(self): a = tensor([1, 3], 'a') feed = {'a': np.array([[1, -1, 3]])} assert_array_almost_equal( operator.relu(a).forward(feed), np.array([[1, 0, 3]]))
from lfdnn import tensor, operator a = tensor([3, 4], 't') print(a.shape) import numpy as np b = operator.relu(a) feed = {'t': np.random.normal(size=[3, 4])} print(b.eval(feed)) print(b.differentiate(a, feed)) print(a.back(b, feed)) w = tensor([4, 1], 'w') b = tensor([1, 1], 'b') h = operator.add(operator.matmul(a, w), b) y = operator.sigmoid(h) feed.update({'w': np.ones([4, 1]), 'b': np.array([[2]])}) y.eval(feed)
def test_log_softmax(self): a = tensor([1, 3], 'a') feed = {'a': np.array([[1, 2, 3]])} assert_array_almost_equal( operator.log_softmax(a).forward(feed), operator.log(operator.softmax(a)).forward(feed))
def test_constant_tensor(self): a = tensor([2, 2], 'a', value=3) assert_array_almost_equal(a.forward({}), 3 * np.ones([2, 2]))