def test_cuda(self, test_case): if not TEST_CUDA or not self.should_test_cuda: raise unittest.SkipTest('Excluded from CUDA tests') try: cpu_input = self._get_input() type_map = { torch.DoubleTensor: torch.cuda.FloatTensor, } gpu_input = to_gpu(cpu_input, type_map=type_map) cpu_target = self.target gpu_target = to_gpu(self.target, type_map=type_map) cpu_module = self.constructor(*self.constructor_args) gpu_module = self.constructor( *self.constructor_args).float().cuda() cpu_output = test_case._forward_criterion(cpu_module, cpu_input, cpu_target) gpu_output = test_case._forward_criterion(gpu_module, gpu_input, gpu_target) test_case.assertEqual(cpu_output, gpu_output, 4e-4) cpu_gradInput = test_case._backward_criterion( cpu_module, cpu_input, cpu_target) gpu_gradInput = test_case._backward_criterion( gpu_module, gpu_input, gpu_target) test_case.assertEqual(cpu_gradInput, gpu_gradInput, 4e-4) except NotImplementedError: pass
def tmp(self): cpu_tensor = tensor_constructor(t) type_map = {} if force_gpu_half: type_map = { 'torch.FloatTensor': 'torch.cuda.HalfTensor', 'torch.DoubleTensor': 'torch.cuda.HalfTensor', } gpu_tensor = to_gpu(cpu_tensor, type_map) cpu_args = arg_constructor(t) gpu_args = [to_gpu(arg, type_map) for arg in cpu_args] cpu_result = getattr(cpu_tensor, fn)(*cpu_args) try: gpu_result = getattr(gpu_tensor, fn)(*gpu_args) except RuntimeError as e: reason = e.args[0] if 'only supports floating-point types' in reason or 'unimplemented data type' in reason: raise unittest.SkipTest('unimplemented data type') raise except AttributeError as e: reason = e.args[0] if 'object has no attribute' in reason: raise unittest.SkipTest('unimplemented data type') raise # If one changes, another should change as well self.assertEqual(cpu_tensor, gpu_tensor, precision) self.assertEqual(cpu_args, gpu_args, precision) # Compare results self.assertEqual(cpu_result, gpu_result, precision)
def test_cuda(self, test_case): if not TEST_CUDA or not self.should_test_cuda: raise unittest.SkipTest('Excluded from CUDA tests') try: cpu_input = self._get_input() type_map = { torch.DoubleTensor: torch.cuda.FloatTensor, } gpu_input = to_gpu(cpu_input, type_map=type_map) cpu_target = self._get_target() gpu_target = to_gpu(cpu_target, type_map=type_map) cpu_module = self.constructor(*self.constructor_args) gpu_module = self.constructor(*self.constructor_args).float().cuda() cpu_output = test_case._forward_criterion(cpu_module, cpu_input, cpu_target) gpu_output = test_case._forward_criterion(gpu_module, gpu_input, gpu_target) test_case.assertEqual(cpu_output, gpu_output, 4e-4) cpu_gradInput = test_case._backward_criterion(cpu_module, cpu_input, cpu_target) gpu_gradInput = test_case._backward_criterion(gpu_module, gpu_input, gpu_target) test_case.assertEqual(cpu_gradInput, gpu_gradInput, 4e-4) except NotImplementedError: pass
def test_cuda(self, test_case): if not TEST_CUDA or not self.should_test_cuda: raise unittest.SkipTest('Excluded from CUDA tests') try: cpu_input = self._get_input() type_map = {torch.DoubleTensor: torch.cuda.FloatTensor} gpu_input = to_gpu(cpu_input, type_map=type_map) cpu_module = self.constructor(*self.constructor_args) gpu_module = self.constructor( *self.constructor_args).float().cuda() cpu_param = test_case._get_parameters(cpu_module) gpu_param = test_case._get_parameters(gpu_module) for cpu_p, gpu_p in zip(cpu_param[0], gpu_param[0]): if isinstance(cpu_p, Variable): cpu_p = cpu_p.data if isinstance(gpu_p, Variable): gpu_p = gpu_p.data gpu_p.copy_(cpu_p) test_case._zero_grad_input(cpu_input) test_case._zero_grad_input(gpu_input) test_case._zero_grad_parameters(cpu_module) test_case._zero_grad_parameters(gpu_module) cpu_output = test_case._forward(cpu_module, cpu_input) gpu_output = test_case._forward(gpu_module, gpu_input) test_case.assertEqual(cpu_output, gpu_output, 2e-4) for i in range(5): cpu_output_t = cpu_output.data if isinstance( cpu_output, Variable) else cpu_output cpu_gradOutput = cpu_output_t.clone().bernoulli_() gpu_gradOutput = cpu_gradOutput.type('torch.cuda.FloatTensor') cpu_gradInput = test_case._backward(cpu_module, cpu_input, cpu_output, cpu_gradOutput) gpu_gradInput = test_case._backward(gpu_module, gpu_input, gpu_output, gpu_gradOutput) test_case.assertEqual(cpu_gradInput, gpu_gradInput, 2e-4) for cpu_d_p, gpu_d_p in zip(cpu_param[1], gpu_param[1]): test_case.assertEqual(cpu_d_p, gpu_d_p, 2e-4) self.test_noncontig(test_case, gpu_module, gpu_input) except NotImplementedError: pass # TODO: remove this after CUDA scatter_ is implemented except AttributeError as e: if len( e.args ) == 1 and "'FloatTensor' object has no attribute 'scatter_'" in e.args[ 0]: pass else: raise
def tmp(self): cpu_tensor = tensor_constructor(t) gpu_tensor = to_gpu(cpu_tensor) cpu_args = arg_constructor(t) gpu_args = [to_gpu(arg) for arg in cpu_args] cpu_result = getattr(cpu_tensor, fn)(*cpu_args) try: gpu_result = getattr(gpu_tensor, fn)(*gpu_args) except RuntimeError as e: reason = e.args[0] if 'unimplemented data type' in reason: raise unittest.SkipTest('unimplemented data type') raise except AttributeError as e: reason = e.args[0] if 'object has no attribute' in reason: raise unittest.SkipTest('unimplemented data type') raise # If one changes, another should change as well self.assertEqual(cpu_tensor, gpu_tensor, precision) self.assertEqual(cpu_args, gpu_args, precision) # Compare results self.assertEqual(cpu_result, gpu_result, precision)
def test_cuda(self, test_case): if not TEST_CUDA or not self.should_test_cuda: raise unittest.SkipTest('Excluded from CUDA tests') try: cpu_input = self._get_input() type_map = {torch.DoubleTensor: torch.cuda.FloatTensor} gpu_input = to_gpu(cpu_input, type_map=type_map) cpu_module = self.constructor(*self.constructor_args) gpu_module = self.constructor(*self.constructor_args).float().cuda() cpu_param = test_case._get_parameters(cpu_module) gpu_param = test_case._get_parameters(gpu_module) for cpu_p, gpu_p in zip(cpu_param[0], gpu_param[0]): if isinstance(cpu_p, Variable): cpu_p = cpu_p.data if isinstance(gpu_p, Variable): gpu_p = gpu_p.data gpu_p.copy_(cpu_p) test_case._zero_grad_input(cpu_input) test_case._zero_grad_input(gpu_input) test_case._zero_grad_parameters(cpu_module) test_case._zero_grad_parameters(gpu_module) cpu_output = test_case._forward(cpu_module, cpu_input) gpu_output = test_case._forward(gpu_module, gpu_input) test_case.assertEqual(cpu_output, gpu_output, 2e-4) for i in range(5): cpu_output_t = cpu_output.data if isinstance(cpu_output, Variable) else cpu_output cpu_gradOutput = cpu_output_t.clone().bernoulli_() gpu_gradOutput = cpu_gradOutput.type('torch.cuda.FloatTensor') cpu_gradInput = test_case._backward(cpu_module, cpu_input, cpu_output, cpu_gradOutput) gpu_gradInput = test_case._backward(gpu_module, gpu_input, gpu_output, gpu_gradOutput) test_case.assertEqual(cpu_gradInput, gpu_gradInput, 2e-4) for cpu_d_p, gpu_d_p in zip(cpu_param[1], gpu_param[1]): test_case.assertEqual(cpu_d_p, gpu_d_p, 2e-4) self.test_noncontig(test_case, gpu_module, gpu_input) except NotImplementedError: pass # TODO: remove this after CUDA scatter_ is implemented except AttributeError as e: if len(e.args) == 1 and "'FloatTensor' object has no attribute 'scatter_'" in e.args[0]: pass else: raise
def test_cuda(self, test_case): if not TEST_CUDA or not self.should_test_cuda: raise unittest.SkipTest('Excluded from CUDA tests') try: cpu_input = self._get_input() type_map = {'torch.DoubleTensor': torch.cuda.FloatTensor} gpu_input = to_gpu(cpu_input, type_map=type_map) cpu_module = self.constructor(*self.constructor_args) gpu_module = self.constructor( *self.constructor_args).float().cuda() cpu_param = test_case._get_parameters(cpu_module) gpu_param = test_case._get_parameters(gpu_module) for cpu_p, gpu_p in zip(cpu_param[0], gpu_param[0]): if isinstance(cpu_p, Variable): cpu_p = cpu_p.data if isinstance(gpu_p, Variable): gpu_p = gpu_p.data gpu_p.copy_(cpu_p) test_case._zero_grad_input(cpu_input) test_case._zero_grad_input(gpu_input) test_case._zero_grad_parameters(cpu_module) test_case._zero_grad_parameters(gpu_module) cpu_output = test_case._forward(cpu_module, cpu_input) gpu_output = test_case._forward(gpu_module, gpu_input) test_case.assertEqual(cpu_output, gpu_output, self.precision) # Run backwards on CPU and GPU and compare results for i in range(5): cpu_gradOutput = cpu_output.clone().normal_() gpu_gradOutput = cpu_gradOutput.type('torch.cuda.FloatTensor') cpu_gradInput = test_case._backward(cpu_module, cpu_input, cpu_output, cpu_gradOutput) gpu_gradInput = test_case._backward(gpu_module, gpu_input, gpu_output, gpu_gradOutput) test_case.assertEqual(cpu_gradInput, gpu_gradInput, self.precision) for cpu_d_p, gpu_d_p in zip(cpu_param[1], gpu_param[1]): test_case.assertEqual(cpu_d_p, gpu_d_p, self.precision) # Run double-backwards on CPU and GPU and compare results if self.check_gradgrad and not self.FIXME_no_cuda_gradgrad_comparison: cpu_output = cpu_module(cpu_input) gpu_output = gpu_module(gpu_input) cpu_gradOutput = Variable(cpu_output.data.clone().normal_(), requires_grad=True) gpu_gradOutput = Variable( cpu_gradOutput.data.type_as(gpu_output), requires_grad=True) cpu_gradInputs = torch.autograd.grad( cpu_output, (cpu_input, ) + tuple(cpu_module.parameters()), cpu_gradOutput, create_graph=True) gpu_gradInputs = torch.autograd.grad( gpu_output, (gpu_input, ) + tuple(gpu_module.parameters()), gpu_gradOutput, create_graph=True) for cpu_d_i, gpu_d_i in zip(cpu_gradInputs, gpu_gradInputs): test_case.assertEqual(cpu_d_i, gpu_d_i, self.precision) # We mix output into the second backwards computation so that # torch.autograd.grad doesn't complain that some inputs # are unreachable (which can happen if you differentiate # only on the gradient. cpu_gg = torch.autograd.grad( cpu_output.sum() + sum(map(lambda x: x.sum(), cpu_gradInputs)), (cpu_input, cpu_gradOutput) + tuple(cpu_module.parameters()), retain_graph=True) gpu_gg = torch.autograd.grad( gpu_output.sum() + sum(map(lambda x: x.sum(), gpu_gradInputs)), (gpu_input, gpu_gradOutput) + tuple(gpu_module.parameters()), retain_graph=True) test_case.assertEqual(cpu_gradInput, gpu_gradInput, self.precision) for cpu_d_p, gpu_d_p in zip(cpu_gg, gpu_gg): test_case.assertEqual(cpu_d_p, gpu_d_p, self.precision) self.test_noncontig(test_case, gpu_module, gpu_input) except NotImplementedError: pass # TODO: remove this after CUDA scatter_ is implemented except AttributeError as e: if len( e.args ) == 1 and "'FloatTensor' object has no attribute 'scatter_'" in e.args[ 0]: pass else: raise
def test_cuda(self, test_case): if not TEST_CUDA or not self.should_test_cuda: raise unittest.SkipTest('Excluded from CUDA tests') try: cpu_input = self._get_input() type_map = {'torch.DoubleTensor': torch.cuda.FloatTensor} gpu_input = to_gpu(cpu_input, type_map=type_map) cpu_module = self.constructor(*self.constructor_args) gpu_module = self.constructor(*self.constructor_args).float().cuda() cpu_param = test_case._get_parameters(cpu_module) gpu_param = test_case._get_parameters(gpu_module) for cpu_p, gpu_p in zip(cpu_param[0], gpu_param[0]): gpu_p.data.copy_(cpu_p) test_case._zero_grad_input(cpu_input) test_case._zero_grad_input(gpu_input) test_case._zero_grad_parameters(cpu_module) test_case._zero_grad_parameters(gpu_module) cpu_output = test_case._forward(cpu_module, cpu_input) gpu_output = test_case._forward(gpu_module, gpu_input) test_case.assertEqual(cpu_output, gpu_output, self.precision) # Run backwards on CPU and GPU and compare results for i in range(5): cpu_gradOutput = cpu_output.clone().normal_() gpu_gradOutput = cpu_gradOutput.type('torch.cuda.FloatTensor') cpu_gradInput = test_case._backward(cpu_module, cpu_input, cpu_output, cpu_gradOutput) gpu_gradInput = test_case._backward(gpu_module, gpu_input, gpu_output, gpu_gradOutput) test_case.assertEqual(cpu_gradInput, gpu_gradInput, self.precision) for cpu_d_p, gpu_d_p in zip(cpu_param[1], gpu_param[1]): test_case.assertEqual(cpu_d_p, gpu_d_p, self.precision) # Run double-backwards on CPU and GPU and compare results if self.check_gradgrad and not self.FIXME_no_cuda_gradgrad_comparison: cpu_output = cpu_module(cpu_input) gpu_output = gpu_module(gpu_input) cpu_gradOutput = torch.randn_like(cpu_output, requires_grad=True) gpu_gradOutput = cpu_gradOutput.type_as(gpu_output).detach() gpu_gradOutput.requires_grad = True cpu_gradInputs = torch.autograd.grad( cpu_output, (cpu_input,) + tuple(cpu_module.parameters()), cpu_gradOutput, create_graph=True) gpu_gradInputs = torch.autograd.grad( gpu_output, (gpu_input,) + tuple(gpu_module.parameters()), gpu_gradOutput, create_graph=True) for cpu_d_i, gpu_d_i in zip(cpu_gradInputs, gpu_gradInputs): test_case.assertEqual(cpu_d_i, gpu_d_i, self.precision) # We mix output into the second backwards computation so that # torch.autograd.grad doesn't complain that some inputs # are unreachable (which can happen if you differentiate # only on the gradient. cpu_gg = torch.autograd.grad( cpu_output.sum() + sum(map(lambda x: x.sum(), cpu_gradInputs)), (cpu_input, cpu_gradOutput) + tuple(cpu_module.parameters()), retain_graph=True) gpu_gg = torch.autograd.grad( gpu_output.sum() + sum(map(lambda x: x.sum(), gpu_gradInputs)), (gpu_input, gpu_gradOutput) + tuple(gpu_module.parameters()), retain_graph=True) test_case.assertEqual(cpu_gradInput, gpu_gradInput, self.precision) for cpu_d_p, gpu_d_p in zip(cpu_gg, gpu_gg): test_case.assertEqual(cpu_d_p, gpu_d_p, self.precision) self.test_noncontig(test_case, gpu_module, gpu_input) except NotImplementedError: pass # TODO: remove this after CUDA scatter_ is implemented except AttributeError as e: if len(e.args) == 1 and "'FloatTensor' object has no attribute 'scatter_'" in e.args[0]: pass else: raise