Refine UT (#88)

Author: EikanWang

tests/cpu/test_interaction.py

@@ -1,58 +1,67 @@
-# numpy
+import math
+import random
+import unittest
+from functools import reduce
+
 import torch
+
 import intel_pytorch_extension as ipex
-# import pcl_embedding_bag
-# import time
-
-def interact_fusion(x, ly):
-    A = [x] + ly
-    R = ipex.interaction(*A)
-    return R
-
-def interact_features(x, ly):
-    (batch_size, d) = x.shape
-    T = torch.cat([x] + ly, dim=1).view((batch_size, -1, d))
-    # Z = pcl_embedding_bag.bdot(T)
-    Z = torch.bmm(T, torch.transpose(T, 1, 2))
-    _, ni, nj = Z.shape
-    offset =  0
-    li = torch.tensor([i for i in range(ni) for j in range(i + offset)], device=ipex.DEVICE)
-    lj = torch.tensor([j for i in range(nj) for j in range(i + offset)], device=ipex.DEVICE)
-    Zflat = Z[:, li, lj]
-    # concatenate dense features and interactions
-    R = torch.cat([x] + [Zflat], dim=1)
-    return R
-
-def run(dtype='float32'):
-    print("##################### testing with %s"% str(dtype))
-    x1 = torch.randn([2048, 128], device=ipex.DEVICE).to(dtype).clone().detach().requires_grad_()
-    x2 = x1.clone().detach().requires_grad_()
-    ly1 = []
-    ly2 = []
-    for i in range(0, 26):
-        V = torch.randn([2048, 128], device=ipex.DEVICE).to(dtype).clone().detach().requires_grad_()
-        ly1.append(V)
-        ly2.append(V.clone().detach().requires_grad_())
-
-    print("##################### interaction forward")
-    A = interact_fusion(x1, ly1)
-    B = interact_features(x2, ly2)
-    if(A.allclose(B, rtol=1e-5, atol=1e-5)):
-        print("##################### interaction forward PASS")
-    else:
-        print("##################### interaction forward FAIL")
-
-    print("##################### interaction backward")
-    A.mean().backward()
-    B.mean().backward()
-    ret = x1.grad.allclose(x2.grad, rtol=1e-5, atol=1e-5)
-    ret = ret and all(ly1[i].grad.allclose(ly2[i].grad, rtol=1e-5, atol=1e-5) for i in range(0, 26))
-    if (ret):
-        print("##################### interaction backward PASS")
-    else:
-        print("##################### interaction backward FAIL")
-
-#dtypes=[torch.float32, torch.bfloat16]
-dtypes=[torch.float32]
-for d in dtypes:
-    run(d)
+
+import torch.nn as nn
+import torch.backends.cudnn as cudnn
+from torch.nn import Parameter
+import torch.nn.functional as F
+from torch.autograd import gradcheck
+from torch.autograd.gradcheck import gradgradcheck
+from torch._six import inf, nan
+
+from common_utils import TestCase, iter_indices, TEST_NUMPY, TEST_SCIPY, TEST_MKL, \
+    TEST_LIBROSA, run_tests, download_file, skipIfNoLapack, suppress_warnings, \
+    IS_WINDOWS, PY3, NO_MULTIPROCESSING_SPAWN, do_test_dtypes, do_test_empty_full, \
+    IS_SANDCASTLE, load_tests, brute_pdist, brute_cdist, slowTest, \
+    skipCUDANonDefaultStreamIf, skipCUDAMemoryLeakCheckIf
+
+class TestInteractionCases(TestCase):
+    def test_interaction(self):
+        def interact_fusion(x, ly):
+            A = [x] + ly
+            R = ipex.interaction(*A)
+            return R
+
+        def interact_features(x, ly):
+            (batch_size, d) = x.shape
+            T = torch.cat([x] + ly, dim=1).view((batch_size, -1, d))
+            # Z = pcl_embedding_bag.bdot(T)
+            Z = torch.bmm(T, torch.transpose(T, 1, 2))
+            _, ni, nj = Z.shape
+            offset =  0
+            li = torch.tensor([i for i in range(ni) for j in range(i + offset)], device=ipex.DEVICE)
+            lj = torch.tensor([j for i in range(nj) for j in range(i + offset)], device=ipex.DEVICE)
+            Zflat = Z[:, li, lj]
+            # concatenate dense features and interactions
+            R = torch.cat([x] + [Zflat], dim=1)
+            return R
+
+        dtypes=[torch.float32]
+        for dtype in dtypes:
+            x1 = torch.randn([2048, 128], device=ipex.DEVICE).to(dtype).clone().detach().requires_grad_()
+            x2 = x1.clone().detach().requires_grad_()
+            ly1 = []
+            ly2 = []
+            for i in range(0, 26):
+                V = torch.randn([2048, 128], device=ipex.DEVICE).to(dtype).clone().detach().requires_grad_()
+                ly1.append(V)
+                ly2.append(V.clone().detach().requires_grad_())
+
+            A = interact_fusion(x1, ly1)
+            B = interact_features(x2, ly2)
+            self.assertEqual(A, B)
+
+            A.mean().backward()
+            B.mean().backward()
+            self.assertEqual(x1.grad, x2.grad)
+            for i in range(0, 26):
+                self.assertEqual(ly1[i].grad, ly2[i].grad)
+
+if __name__ == '__main__':
+    test = unittest.main()

tests/cpu/test_lazy_reorder.py

@@ -732,9 +732,9 @@ def test_adaptive_avg_pool2d_backward(self):
         y_cpu.backward()
         y_dpcpp.backward()
         self.assertEqual(x_cpu.grad, x_dpcpp.grad)
-    
+
     def test_adaptive_avg_pool2d_not_divisible(self):
-        ipex.enable_auto_dnnl()
+        ipex.core.enable_auto_dnnl()
         rand_seed = int(get_rand_seed())
         print("{} rand sed: {}".format(sys._getframe().f_code.co_name, rand_seed))
         torch.manual_seed(rand_seed)
@@ -755,7 +755,7 @@ def test_adaptive_avg_pool2d_not_divisible(self):
         self.assertEqual(device, y_dpcpp.device.type)
 
     def test_adaptive_avg_pool2d_backward_not_divisible(self):
-        ipex.enable_auto_dnnl()
+        ipex.core.enable_auto_dnnl()
         rand_seed = int(get_rand_seed())
         print("{} rand sed: {}".format(sys._getframe().f_code.co_name, rand_seed))
         torch.manual_seed(rand_seed)
@@ -796,9 +796,9 @@ def test_max_pool2d(self):
                         ceil_mode=ceil_mode)
 
                     self.assertEqual(max_pool2d(x_cpu), max_pool2d(x_dpcpp))
-    
+
     def test_max_pool2d_double(self):
-        ipex.enable_auto_dnnl()
+        ipex.core.enable_auto_dnnl()
         rand_seed = int(get_rand_seed())
         print("{} rand sed: {}".format(sys._getframe().f_code.co_name, rand_seed))
         torch.manual_seed(rand_seed)
@@ -817,7 +817,7 @@ def test_max_pool2d_double(self):
                         stride=stride,
                         padding=1,
                         ceil_mode=ceil_mode)
-                    
+
                     y_cpu = max_pool2d(x_cpu)
                     y_dpcpp = max_pool2d(x_dpcpp)
                     self.assertEqual(y_cpu, y_dpcpp)
@@ -867,9 +867,9 @@ def test_max_pool2d_backward(self):
             y1.backward()
             y2.backward()
             self.assertEqual(x1.grad, x2.grad)
-    
+
     def test_max_pool2d_backward_double(self):
-        ipex.enable_auto_dnnl()
+        ipex.core.enable_auto_dnnl()
         rand_seed = int(get_rand_seed())
         print("{} rand sed: {}".format(sys._getframe().f_code.co_name, rand_seed))
         torch.manual_seed(rand_seed)