def test_sse(self): ss = SSE() assert ss.value == 0.0 refs = CPUTensor([0.00, 1, 0.7, -0.4]) preds = CPUTensor([0.2, -1, 0.5, 2.4]) ss.add(refs, preds) assert abs(ss.report() - (0.2**2 + 2**2 + 0.2**2 + 2.8**2)) < 1e-5
def test_neginfnorm(self): tsr = self.be.array([[-1, 0], [1, 3]]) # -> min(abs(tsr), axis=0) -> [1, 0] assert_tensor_equal(self.be.norm(tsr, order=float('-inf'), axis=0), CPUTensor([[1, 0]])) # -> min(abs(tsr), axis=1) -> [0, 1] assert_tensor_equal(self.be.norm(tsr, order=float('-inf'), axis=1), CPUTensor([0, 1]))
def test_0norm(self): tsr = self.be.array([[-1, 0], [1, 3]]) # -> sum(tsr != 0, axis=0) -> [2, 1] assert_tensor_equal(self.be.norm(tsr, order=0, axis=0), CPUTensor([[2, 1]])) # -> sum(tsr != 0, axis=1) -> [1, 2] assert_tensor_equal(self.be.norm(tsr, order=0, axis=1), CPUTensor([1, 2]))
def test_infnorm(self): tsr = self.be.array([[-1, 0], [1, 3]]) # -> max(abs(tsr), axis=0) -> [1, 3] assert_tensor_equal(self.be.norm(tsr, order=float('inf'), axis=0), CPUTensor([[1, 3]])) # -> max(abs(tsr), axis=1) -> [1, 3] assert_tensor_equal(self.be.norm(tsr, order=float('inf'), axis=1), CPUTensor([1, 3]))
def test_sse_mat(self): ss = SSE() assert ss.value == 0.0 refs = CPUTensor([[0, 1, 0.7], [0.5, -3, 0]]) preds = CPUTensor([[0.2, 1, 0.5], [0, -5.5, 0.10]]) ss.add(refs, preds) assert abs(ss.report() - (0.2**2 + 0**2 + 0.2**2 + 0.5**2 + 2.5**2 + .10**2)) < 1e-5
def test_1norm(self): tsr = self.be.array([[-1, 0], [1, 3]]) # -> sum([[1, 0], [1, 3]], axis=0)**1 -> [2, 3] assert_tensor_equal(self.be.norm(tsr, order=1, axis=0), CPUTensor([[2, 3]])) # -> sum([[1, 0], [1, 3]], axis=1)**1 -> [1, 4] assert_tensor_equal(self.be.norm(tsr, order=1, axis=1), CPUTensor([1, 4]))
def test_mse(self): ms = MSE() assert ms.value == 0.0 refs = CPUTensor([0.00, 1, 0.7, -0.4]) preds = CPUTensor([0.2, -1, 0.5, 2.4]) ms.add(refs, preds) assert abs(ms.report() - ((0.2**2 + 2**2 + 0.2**2 + 2.8**2) / 4.0)) < 1e-5
def test_range_slicing(self): tns = CPUTensor([[1, 2], [3, 4]]) res = tns[0:2, 0] expected_shape = (2, ) while len(expected_shape) < res._min_dims: expected_shape += (1, ) assert res.shape == expected_shape assert_tensor_equal(res, CPUTensor([1, 3]))
def test_softmax_cputensor(): sftmx = Softmax() inputs = np.array([0, 1, -2]).reshape((3, 1)) be = CPU(rng_seed=0) temp = be.zeros((3, 1)) outputs = np.exp(inputs - 1) / np.sum(np.exp(inputs - 1)) sftmx.apply_function(be, CPUTensor(inputs), temp) assert_tensor_near_equal(CPUTensor(outputs), temp)
def test_logistic_cputensor(): lgstc = Logistic() inputs = np.array([0, 1, -2]).reshape((3, 1)) be = CPU(rng_seed=0) temp = be.zeros((3, 1)) outputs = 1.0 / (1.0 + np.exp(-inputs)) lgstc.apply_function(be, CPUTensor(inputs), temp) assert_tensor_near_equal(CPUTensor(outputs), temp)
def test_2norm(self): tsr = self.be.array([[-1, 0], [1, 3]]) rpow = 1. / 2 # -> sum([[1, 0], [1, 9]], axis=0)**.5 -> sqrt([2, 9]) assert_tensor_equal(self.be.norm(tsr, order=2, axis=0), CPUTensor([[2**rpow, 9**rpow]])) # -> sum([[1, 0], [1, 9]], axis=1)**.5 -> sqrt([1, 10]) assert_tensor_equal(self.be.norm(tsr, order=2, axis=1), CPUTensor([1**rpow, 10**rpow]))
def test_tanh_derivative_cputensor(): tntest = Tanh() inputs = np.array([0, 1, -2]) be = CPU(rng_seed=0) outputs = np.array( [1 - true_tanh(0)**2, 1 - true_tanh(1)**2, 1 - true_tanh(-2)**2]) temp = be.zeros(inputs.shape) tntest.apply_derivative(be, CPUTensor(inputs), temp) assert_tensor_near_equal(CPUTensor(outputs), temp)
def test_tanh_cputensor(): tntest = Tanh() be = CPU(rng_seed=0) CPUTensor([0, 1, -2]) inputs = np.array([0, 1, -2]) temp = be.zeros(inputs.shape) outputs = np.array([true_tanh(0), true_tanh(1), true_tanh(-2)]) tntest.apply_function(be, CPUTensor(inputs), temp) assert_tensor_near_equal(CPUTensor(outputs), temp)
def test_misclass_sum_add_binary(self): mcs = MisclassSum() assert mcs.rec_count == 0 assert mcs.misclass_sum == 0 refs = CPUTensor([[0, 1, 0, 0]]) preds = CPUTensor([[1, 1, 0, 1]]) mcs.add(refs, preds) assert mcs.rec_count == 4 assert mcs.misclass_sum == 2
def test_logistic_derivative_cputensor(): lgstc = Logistic() inputs = np.array([0, 1, -2]).reshape((3, 1)) be = CPU(rng_seed=0) outputs = 1.0 / (1.0 + np.exp(-inputs)) outputs = outputs * (1.0 - outputs) temp = be.zeros(inputs.shape) lgstc.apply_derivative(be, CPUTensor(inputs), temp) assert_tensor_near_equal(CPUTensor(outputs), temp)
def test_logloss_sum_mixed(self): ll = LogLossSum() assert ll.logloss == 0.0 refs = CPUTensor([1, 0, 1]).transpose() preds = CPUTensor([[0.00, 1, 0], [0.09, 0.0, 0.75], [0.01, 0, 0.15], [0.90, 0, 0.10]]) ll.add(refs, preds) assert abs(ll.report() + (math.log(.09) + math.log(1.0 - ll.eps) + math.log(0.75))) < 1e-6
def test_mse_mat(self): ms = MSE() assert ms.value == 0.0 assert ms.rec_count == 0.0 refs = CPUTensor([[0, 1, 0.7], [0.5, -3, 0]]) preds = CPUTensor([[0.2, 1, 0.5], [0, -5.5, 0.10]]) ms.add(refs, preds) assert abs(ms.report() - ( (0.2**2 + 0**2 + 0.2**2 + 0.5**2 + 2.5**2 + .10**2) / 6.0)) < 1e-6
def compare_cpu_tensors(inputs, outputs, deriv=False): rlin = RectLeaky() be = CPU() temp = be.zeros(inputs.shape) if deriv is True: rlin.apply_derivative(be, CPUTensor(inputs), temp) else: rlin.apply_function(be, CPUTensor(inputs), temp) be.subtract(temp, CPUTensor(outputs), temp) assert_tensor_equal(temp, be.zeros(inputs.shape))
def test_misclass_rate_report(self): mcr = MisclassRate() assert mcr.rec_count == 0 assert mcr.misclass_sum == 0 refs = CPUTensor([[0, 1, 0, 0]]) preds = CPUTensor([[1, 1, 0, 1]]) mcr.add(refs, preds) assert mcr.rec_count == 4 assert mcr.misclass_sum == 2 assert mcr.report() == 0.5
def test_misclass_pct_report(self): mcp = MisclassPercentage() assert mcp.rec_count == 0 assert mcp.misclass_sum == 0 refs = CPUTensor([[0, 1, 0, 0]]) preds = CPUTensor([[1, 1, 0, 1]]) mcp.add(refs, preds) assert mcp.rec_count == 4 assert mcp.misclass_sum == 2 assert mcp.report() == 50.0
def test_lrgnorm(self): tsr = self.be.array([[-1, 0], [1, 3]]) rpow = 1. / 5 # -> sum([[1, 0], [1, 243]], axis=0)**rpow -> rpow([2, 243]) assert_tensor_equal(self.be.norm(tsr, order=5, axis=0), CPUTensor([[2**rpow, 243**rpow]])) # -> sum([[1, 0], [1, 243]], axis=1)**rpow -> rpow([1, 244]) # 244**.2 == ~3.002465 hence the near_equal test assert_tensor_near_equal(self.be.norm(tsr, order=5, axis=1), CPUTensor([1**rpow, 244**rpow]), 1e-6)
def test_misclass_sum_mixed(self): mcs = MisclassSum() assert mcs.rec_count == 0 assert mcs.misclass_sum == 0 refs = CPUTensor([[3, 0, 1]]) preds = CPUTensor([[0.00, 1, 0], [0.09, 0.0, 0.55], [0.01, 0, 0.75], [0.90, 0, 0.34]]) mcs.add(refs, preds) assert mcs.rec_count == 3 assert mcs.misclass_sum == 1
def test_cross_entropy_derivative_cputensor(): be = CPU(rng_seed=0) outputs = CPUTensor([0.5, 0.9, 0.1, 0.0001]) targets = CPUTensor([0.5, 0.99, 0.01, 0.2]) temp = [be.zeros(outputs.shape), be.zeros(outputs.shape)] expected_result = ((outputs.asnumpyarray() - targets.asnumpyarray()) / (outputs.asnumpyarray() * (1 - outputs.asnumpyarray()))) assert_tensor_near_equal(expected_result, cross_entropy_derivative(be, outputs, targets, temp))
def test_auc_add_binary(self): auc = AUC() assert auc.num_pos == 0 assert auc.num_neg == 0 refs = CPUTensor([[0, 1, 0, 0]]) preds = CPUTensor([[1, 1, 0, 1]]) auc.add(refs, preds) assert auc.num_pos == 1 assert auc.num_neg == 3 assert len(auc.probs) == 4 assert len(auc.labels) == 4
def test_logloss_mean(self): ll = LogLossMean() assert ll.logloss == 0.0 assert ll.rec_count == 0.0 refs = CPUTensor([[0, 1, 0], [1, 0, 1], [0, 0, 0], [0, 0, 0]]) preds = CPUTensor([[0.00, 1, 0], [0.09, 0.0, 0.75], [0.01, 0, 0.15], [0.90, 0, 0.10]]) ll.add(refs, preds) assert abs(ll.report() + (math.log(.09) + math.log(1.0 - ll.eps) + math.log(0.75)) / 3.0) < 1e-6
def test_negnorm(self): tsr = self.be.array([[-1, -2], [1, 3]]) rpow = -1. / 3 # -> sum([[1, .125], [1, .037037]], axis=0)**rpow -> rpow([2, .162037]) assert_tensor_equal(self.be.norm(tsr, order=-3, axis=0), CPUTensor([[2**rpow, .162037037037**rpow]])) # -> sum([[1, .125], [1, .037037]], axis=1)**rpow -> # rpow([1.125, 1.037037]) assert_tensor_near_equal(self.be.norm(tsr, order=-3, axis=1), CPUTensor([1.125**rpow, 1.037037**rpow]), 1e-6)
def test_misclass_sum_top3probs(self): mcs = MisclassSum(error_rank=3) assert mcs.rec_count == 0 assert mcs.misclass_sum == 0 refs = CPUTensor([[0.03, 0.80, 0.81], [0.20, 0.02, 0.15], [0.31, 0.08, 0.01], [0.46, 0.10, 0.03]]) preds = CPUTensor([[0.00, 1, 0.34], [0.09, 0.0, 0.55], [0.01, 0, 0.75], [0.90, 0, 0.00]]) mcs.add(refs, preds) assert mcs.rec_count == 3 assert mcs.misclass_sum == 0
def test_softmax_derivative_cputensor(): sftmx = Softmax() inputs = np.array([0, 1, -2]).reshape((3, 1)) be = CPU(rng_seed=0) outputs = np.exp(inputs) / np.sum(np.exp(inputs)) errmat = np.ones(inputs.shape) a = np.einsum('ij,ji->i', errmat.T, outputs) outputs = outputs * (errmat - a[np.newaxis, :]) temp = be.zeros(inputs.shape) sftmx.apply_derivative(be, CPUTensor(inputs), temp) assert_tensor_near_equal(CPUTensor(outputs), temp)
def test_auc_add_mixed(self): auc = AUC() assert auc.num_pos == 0 assert auc.num_neg == 0 refs = CPUTensor([[0, 1, 0]]) preds = CPUTensor([[0.00, 1, 0], [0.09, 0.0, 0.75], [0.01, 0, 0.15], [0.90, 0, 0.10]]) auc.add(refs, preds) assert auc.num_pos == 1 assert auc.num_neg == 2 assert len(auc.probs) == 3 assert len(auc.labels) == 3
def test_auc_add_probs(self): auc = AUC() assert auc.num_pos == 0 assert auc.num_neg == 0 refs = CPUTensor([[0.03, 0.80, 0.01], [0.20, 0.02, 0.80], [0.31, 0.08, 0.01], [0.46, 0.10, 0.03]]) preds = CPUTensor([[0.00, 1, 0], [0.09, 0.0, 0.75], [0.01, 0, 0.15], [0.90, 0, 0.10]]) auc.add(refs, preds) assert auc.num_pos == 1 assert auc.num_neg == 2 assert len(auc.probs) == 3 assert len(auc.labels) == 3
def test_greater(self): left = self.be.array([[-1, 0], [1, 92]]) right = self.be.ones([2, 2]) out = self.be.empty([2, 2]) self.be.greater(left, right, out) assert out.shape == (2, 2) assert_tensor_equal(out, CPUTensor([[0, 0], [0, 1]]))
def test_cross_entropy_cputensor(): be = CPU(rng_seed=0) outputs = CPUTensor([0.5, 0.9, 0.1, 0.0001]) targets = CPUTensor([0.5, 0.99, 0.01, 0.2]) temp = [be.zeros(outputs.shape), be.zeros(outputs.shape)] expected_result = np.sum((- targets.asnumpyarray()) * np.log(outputs.asnumpyarray()) - (1 - targets.asnumpyarray()) * np.log(1 - outputs.asnumpyarray()), keepdims=True) assert_tensor_near_equal(expected_result, cross_entropy(be, outputs, targets, temp))
def test_asnumpyarray(self): tns = CPUTensor([[1, 2], [3, 4]]) res = tns.asnumpyarray() assert isinstance(res, np.ndarray) assert_tensor_equal(res, np.array([[1, 2], [3, 4]]))
def test_transpose(self): tns = CPUTensor([[1, 2], [3, 4]]) res = tns.transpose() assert_tensor_equal(res, CPUTensor([[1, 3], [2, 4]]))
def test_fill(self): tns = CPUTensor([[1, 2], [3, 4]]) tns.fill(-9.5) assert_tensor_equal(tns, CPUTensor([[-9.5, -9.5], [-9.5, -9.5]]))