def test_conv_add_relu_(self):
ipex.enable_auto_dnnl()
rand_seed = int(get_rand_seed())
print("{} rand sed: {}".format(sys._getframe().f_code.co_name,
rand_seed))
res_dcpp_dnnl, input_dpcpp_dnnl, _ = self._test_conv_add_relu_(
"dpcpp:0", rand_seed)
ipex.disable_auto_dnnl()
res_dcpp_cpu, input_dpcpp_cpu, _ = self._test_conv_add_relu_(
"dpcpp:0", rand_seed)
res_cpu, input_cpu, _ = self._test_conv_add_relu_("cpu", rand_seed)
self.assertEqual(res_cpu, res_dcpp_cpu.to('cpu'))
self.assertEqual(res_cpu, res_dcpp_dnnl.to('cpu'))
ipex.enable_auto_dnnl()
res_dcpp_dnnl.sum().backward()
res_dcpp_cpu.sum().backward()
res_cpu.sum().backward()
self.assertEqual(input_dpcpp_dnnl.grad.to('cpu'),
input_cpu.grad,
prec=0.0)
self.assertEqual(input_dpcpp_cpu.grad.to('cpu'),
input_cpu.grad,
prec=0.0)
def test_seq_conv(self):
ipex.disable_auto_dnnl()
rand_seed = int(get_rand_seed())
print("{} rand sed: {}".format(sys._getframe().f_code.co_name,
rand_seed))
res_cpu = self._seq_conf('cpu', rand_seed)
ipex.enable_auto_dnnl()
res_dpcpp = self._seq_conf(device, rand_seed)
self.assertEqual(res_cpu, res_dpcpp.to('cpu'))
def test_add_(self):
ipex.enable_auto_dnnl()
rand_seed = int(get_rand_seed())
print("{} rand sed: {}".format(sys._getframe().f_code.co_name,
rand_seed))
res_dcpp_dnnl = self._test_add_("dpcpp:0", rand_seed)
ipex.disable_auto_dnnl()
res_dcpp_cpu = self._test_add_("dpcpp:0", rand_seed)
res_cpu = self._test_add_("cpu", rand_seed)
self.assertEqual(res_cpu, res_dcpp_cpu.to('cpu'))
self.assertEqual(res_cpu, res_dcpp_dnnl.to('cpu'))
def test_Conv2d_with_cpu(self):
rand_seed = int(get_rand_seed())
print("{} rand sed: {}".format(sys._getframe().f_code.co_name,
rand_seed))
torch.manual_seed(rand_seed)
conv_cpu = torch.nn.Conv2d(1, 1, (3, 3))
conv_dpcpp = torch.nn.Conv2d(1, 1, (3, 3)).to(device=device)
conv_dpcpp.weight.data = conv_cpu.weight.data.to(device=device)
conv_dpcpp.bias.data = conv_cpu.bias.data.to(device=device)
input_cpu = torch.rand((1, 1, 7, 7))
input_dpcpp = input_cpu.to(device=device)
ipex.enable_auto_dnnl()
out_dpcpp = conv_dpcpp(input_dpcpp)
ipex.disable_auto_dnnl()
out_dpcpp_cpu = out_dpcpp.to('cpu')
out_cpu = conv_cpu(input_cpu)
self.assertEqual(out_dpcpp.size(), out_cpu.size())
self.assertEqual(out_cpu, out_dpcpp_cpu)
def test_auto_dnnl(self):
self.assertTrue(ipex.get_auto_dnnl())
ipex.disable_auto_dnnl()
self.assertFalse(ipex.get_auto_dnnl())
ipex.enable_auto_dnnl()
self.assertTrue(ipex.get_auto_dnnl())
def test_view(self):
tensor = torch.rand(15, device=device)
template = torch.rand(3, 5, device=device)
target = template.size()
self.assertEqual(tensor.view_as(template).size(), target)
self.assertEqual(tensor.view(3, 5).size(), target)
self.assertEqual(tensor.view(torch.Size([3, 5])).size(), target)
self.assertEqual(tensor.view(-1, 5).size(), target)
self.assertEqual(tensor.view(3, -1).size(), target)
tensor_view = tensor.view(5, 3)
tensor_view.fill_(random.uniform(0, 1))
empty = torch.empty(0, device=device)
self.assertEqual(empty.view_as(empty), empty)
self.assertEqual(empty.view(0), empty)
self.assertEqual(
empty.view(0, 3, 0, 1).size(), torch.Size([0, 3, 0, 1]))
self.assertEqual(empty.view(0, 3, 0, 1).view(0), empty)
# test size inference with empty tensors
self.assertEqual(empty.view(-1).size(), torch.Size([0]))
self.assertEqual(empty.view(10, 3, -1).size(), torch.Size([10, 3, 0]))
with self.assertRaisesRegex(
RuntimeError,
r"because the unspecified dimension size -1 can be any value"):
empty.view(-1, 0)
with self.assertRaisesRegex(
RuntimeError,
r"because the unspecified dimension size -1 can be any value"):
empty.view(3, 0, -1, 0)
self.assertRaises(RuntimeError, lambda: tensor.view(15, 0))
self.assertRaises(RuntimeError, lambda: tensor.view(7, -1))
self.assertRaises(RuntimeError, lambda: tensor.view(15, -1, -1))
# TODO(Eikan): DNNL OP does not support >6 dim tensor, so we disable it temporily. When we fix it, we will open it
old_dnnl_conf = ipex.get_auto_dnnl()
ipex.disable_auto_dnnl()
# test view when tensor is not contiguous in every dimension, but only
# contiguous dimensions are touched.
tensor = torch.rand(4, 2, 5, 1, 6, 2, 9, 3,
device=device).transpose(-1, 2).transpose(-2, 3)
# size: [ 4, 2, 3, 9, 6, 2, 1, 5]
# stride: [3840, 1620, 1, 3, 54, 27, 324, 324]
# contiguous dim chunks: [__________, ____, ____, __________, ____, ____]
# merging 1 to chunk after: [__________, ____, ____, __________, __________]
contig_tensor = tensor.clone()
# [4, 2] => [8, 1]
# [3] => [3]
# [9] => [3, 3]
# [6, 2] => [4, 1, 3]
# [1, 5] => [5]
view_size = [8, 1, 3, 3, 3, 4, 1, 3, 5]
self.assertEqual(tensor.view(*view_size),
contig_tensor.view(*view_size))
# [4, 2] => [2, 4]
# [3] => [3]
# [9] => [1, 9]
# [6, 2] => [2, 2, 3]
# [1, 5] => [5, 1]
view_size = [2, 4, 3, 1, 9, 2, 2, 3, 5, 1]
self.assertEqual(tensor.view(*view_size),
contig_tensor.view(*view_size))
# adding size 1 dims
view_size = [1, 1, 2, 1, 4, 3, 1, 1, 9, 1, 2, 1, 2, 3, 1, 5, 1, 1]
self.assertEqual(tensor.view(*view_size),
contig_tensor.view(*view_size))
if old_dnnl_conf:
ipex.enable_auto_dnnl()
else:
ipex.disable_auto_dnnl()
# invalid views
self.assertRaises(RuntimeError, lambda: tensor.view(-1))
# crossing [4, 2], [3]
self.assertRaises(RuntimeError, lambda: tensor.view(24, 9, 6, 2, 1, 5))
# crossing [6, 2], [1, 5]
self.assertRaises(RuntimeError, lambda: tensor.view(8, 3, 9, 6, 10))
# crossing [9], [6, 2]
self.assertRaises(RuntimeError, lambda: tensor.view(8, 3, 54, 2, 1, 5))
# view with stride 0 dims
tensor = torch.empty(1, 1, device=device).expand(
3, 4) # all dims are contiguous
contig_tensor = tensor.clone()
self.assertEqual(tensor.view(-1), contig_tensor.view(-1))
self.assertEqual(tensor.view(1, -1, 1), contig_tensor.view(1, -1, 1))
self.assertEqual(tensor.view(-1, 1), contig_tensor.view(-1, 1))
self.assertEqual(tensor.view(6, 2, 1), contig_tensor.view(6, 2, 1))
self.assertEqual(tensor.view(1, 6, 2, 1),
contig_tensor.view(1, 6, 2, 1))
inputs_cpu = torch.randn(0, 6, requires_grad=True)
inputs_dpcpp = inputs_cpu.detach().to(
device=device).requires_grad_(True)
out_dpcpp = inputs_dpcpp.view(1, 0, 6, 1, 1)
out_cpu = inputs_cpu.view(1, 0, 6, 1, 1)
self.assertEqual(out_dpcpp.to('cpu'), out_cpu, prec=0.0)
out_dpcpp.sum().backward()
out_cpu.sum().backward()
self.assertEqual(inputs_dpcpp.grad.to('cpu'),
inputs_cpu.grad,
prec=0.0)
