Update for latest pytorch

Author: mattdawkins

mmcv/onnx/onnx_utils/symbolic_helper.py

@@ -134,7 +134,7 @@ def _if_scalar_type_as(g, self, tensor):
     if isinstance(self, torch._C.Value):
         return self
 
-    scalar_type = tensor.type().scalarType()
+    scalar_type = tensor.scalar_type().scalarType()
     if scalar_type:
         ty = scalar_type.lower()
         return getattr(self, ty)()
@@ -151,7 +151,7 @@ def _is_value(x):
 
 
 def _is_tensor_list(x):
-    return x.type().isSubtypeOf(ListType.ofTensors())
+    return x.scalar_type().isSubtypeOf(ListType.ofTensors())
 
 
 def _unimplemented(op, msg):
@@ -162,7 +162,7 @@ def _unimplemented(op, msg):
 def _try_get_scalar_type(*args):
     for arg in args:
         try:
-            return arg.type().scalarType()
+            return arg.scalar_type().scalarType()
         except RuntimeError:
             pass
     return None
@@ -218,7 +218,7 @@ def _interpolate_size_to_scales(g, input, output_size, dim):
     else:
         scales_constant = [
             1. if i < 2 else float(output_size[-(dim - i)]) /
-            float(input.type().sizes()[-(dim - i)]) for i in range(0, dim)
+            float(input.scalar_type().sizes()[-(dim - i)]) for i in range(0, dim)
         ]
         scales = g.op(
             'Constant',
@@ -233,9 +233,9 @@ def _interpolate_get_scales_if_available(g, scales):
     # scales[0] is TensorType with sizes = [] in Pytorch == 1.6.0
     # scales[0] is ListType in Pytorch == 1.7.0
     # scales[0] is TensorType with sizes = [2] in Pytorch == 1.8.0
-    scale_desc = 'fs' if scales[0].type().kind() == 'ListType' or (
-        scales[0].type().kind() == 'TensorType' and
-        (sum(scales[0].type().sizes()) > 1)) else 'f'
+    scale_desc = 'fs' if scales[0].scalar_type().kind() == 'ListType' or (
+        scales[0].scalar_type().kind() == 'TensorType' and
+        (sum(scales[0].scalar_type().sizes()) > 1)) else 'f'
     available_scales = _maybe_get_const(
         scales[0], scale_desc) != -1 and not _is_none(scales[0])
 
@@ -276,7 +276,7 @@ def _get_interpolate_attributes(g, mode, args):
 
 def _interpolate_get_scales(g, scale_factor, dim):
     offsets = g.op('Constant', value_t=torch.ones(2, dtype=torch.float32))
-    if isinstance(scale_factor.type(), torch._C.ListType):
+    if isinstance(scale_factor.scalar_type(), torch._C.ListType):
         return g.op('Concat', offsets, scale_factor, axis_i=0)
     else:
         scale_factor = _unsqueeze_helper(g, scale_factor, 0)

mmcv/onnx/symbolic.py

@@ -26,7 +26,7 @@ def symbolic_fn(g, input, output_size, *args):
         if scales is None:
             if 'ONNX_BACKEND' in os.environ and os.environ[
                     'ONNX_BACKEND'] == 'TensorRT':
-                input_size = input.type().sizes()
+                input_size = input.scalar_type().sizes()
                 # slice the first two dim
                 input_size = input_size[:2]
                 # convert output_size to int type
@@ -132,13 +132,13 @@ def constant_pad_nd(g, input, padding, value=None):
     mode = 'constant'
     value = sym_help._maybe_get_scalar(value)
     value = sym_help._if_scalar_type_as(g, value, input)
-    pad = _prepare_onnx_paddings(g, input.type().dim(), padding)
+    pad = _prepare_onnx_paddings(g, input.scalar_type().dim(), padding)
     return g.op('Pad', input, pad, value, mode_s=mode)
 
 
 def reflection_pad(g, input, padding):
     mode = 'reflect'
-    paddings = _prepare_onnx_paddings(g, input.type().dim(), padding)
+    paddings = _prepare_onnx_paddings(g, input.scalar_type().dim(), padding)
     return g.op('Pad', input, paddings, mode_s=mode)
 
 
@@ -294,7 +294,7 @@ def one_hot(g, self, num_classes):
 
 @parse_args('v', 'i', 'none')
 def softmax(g, input, dim, dtype=None):
-    input_dim = input.type().dim()
+    input_dim = input.scalar_type().dim()
     if input_dim:
         # TODO: remove this as onnx opset 11 spec allows negative axes
         if dim < 0:
@@ -332,7 +332,7 @@ def symbolic_fn(g, input, output_size):
                 return g.op('GlobalMaxPool', input), None
             raise NotImplementedError(
                 '[Adaptive pool]:input size not accessible')
-        dim = input.type().sizes()[2:]
+        dim = input.scalar_type().sizes()[2:]
         if output_size == [1] * len(output_size) and type == 'MaxPool':
             return g.op('GlobalMaxPool', input), None
 
@@ -375,7 +375,7 @@ def new_full(g,
              pin_memory=False):
     from torch.onnx.symbolic_opset9 import full
     if dtype is None and self.isCompleteTensor():
-        dtype = self.type().scalarType()
+        dtype = self.scalar_type().scalarType()
         dtype = sym_help.scalar_type_to_onnx.index(
             sym_help.cast_pytorch_to_onnx[dtype])
     return full(g, size, fill_value, dtype, layout, device, pin_memory)

mmcv/ops/csrc/parrots/ms_deform_attn.cpp

@@ -32,7 +32,7 @@ Tensor ms_deform_attn_forward(const Tensor &value, const Tensor &spatial_shapes,
                               const Tensor &sampling_loc,
                               const Tensor &attn_weight,
                               const int im2col_step) {
-  if (value.type().is_cuda()) {
+  if (value.scalar_type().is_cuda()) {
 #ifdef MMCV_WITH_CUDA
     CHECK_CUDA_INPUT(value)
     CHECK_CUDA_INPUT(spatial_shapes)
@@ -55,7 +55,7 @@ void ms_deform_attn_backward(const Tensor &value, const Tensor &spatial_shapes,
                              const Tensor &grad_output, Tensor &grad_value,
                              Tensor &grad_sampling_loc,
                              Tensor &grad_attn_weight, const int im2col_step) {
-  if (value.type().is_cuda()) {
+  if (value.scalar_type().is_cuda()) {
 #ifdef MMCV_WITH_CUDA
     CHECK_CUDA_INPUT(value)
     CHECK_CUDA_INPUT(spatial_shapes)

mmcv/ops/csrc/parrots/nms_rotated_cpu.cpp

@@ -11,9 +11,9 @@ Tensor nms_rotated_cpu_kernel(const Tensor dets, const Tensor scores,
   // however, the code in this function is much shorter because
   // we delegate the IoU computation for rotated boxes to
   // the single_box_iou_rotated function in box_iou_rotated_utils.h
-  AT_ASSERTM(!dets.type().is_cuda(), "dets must be a CPU tensor");
-  AT_ASSERTM(!scores.type().is_cuda(), "scores must be a CPU tensor");
-  AT_ASSERTM(dets.type() == scores.type(),
+  AT_ASSERTM(!dets.scalar_type().is_cuda(), "dets must be a CPU tensor");
+  AT_ASSERTM(!scores.scalar_type().is_cuda(), "scores must be a CPU tensor");
+  AT_ASSERTM(dets.scalar_type() == scores.scalar_type(),
              "dets should have the same type as scores");
 
   if (dets.numel() == 0) {
@@ -59,7 +59,7 @@ Tensor nms_rotated_cpu_kernel(const Tensor dets, const Tensor scores,
 Tensor nms_rotated_cpu(const Tensor dets, const Tensor scores,
                        const float iou_threshold) {
   auto result = at::empty({0}, dets.options());
-  AT_DISPATCH_FLOATING_TYPES(dets.type(), "nms_rotated", [&] {
+  AT_DISPATCH_FLOATING_TYPES(dets.scalar_type(), "nms_rotated", [&] {
     result = nms_rotated_cpu_kernel<scalar_t>(dets, scores, iou_threshold);
   });
   return result;

mmcv/ops/csrc/pytorch/cpu/nms_rotated.cpp

@@ -59,7 +59,7 @@ Tensor nms_rotated_cpu_kernel(const Tensor dets, const Tensor scores,
 Tensor nms_rotated_cpu(const Tensor dets, const Tensor scores,
                        const float iou_threshold) {
   auto result = at::empty({0}, dets.options());
-  AT_DISPATCH_FLOATING_TYPES(dets.type(), "nms_rotated", [&] {
+  AT_DISPATCH_FLOATING_TYPES(dets.scalar_type(), "nms_rotated", [&] {
     result = nms_rotated_cpu_kernel<scalar_t>(dets, scores, iou_threshold);
   });
   return result;

mmcv/ops/csrc/pytorch/cuda/psamask_cuda.cu

@@ -2,7 +2,6 @@
 // Modified from
 // https://github.com/hszhao/semseg/blob/master/lib/psa/src
 
-#include <THC/THC.h>
 #include <torch/serialize/tensor.h>
 
 #include <THC/THCDeviceUtils.cuh>

mmcv/ops/sync_bn.py

@@ -46,7 +46,7 @@ def forward(self, input, running_mean, running_var, weight, bias, momentum,
         assert isinstance(
                    input, (torch.HalfTensor, torch.FloatTensor,
                            torch.cuda.HalfTensor, torch.cuda.FloatTensor)), \
-               f'only support Half or Float Tensor, but {input.type()}'
+               f'only support Half or Float Tensor, but {input.scalar_type()}'
         output = torch.zeros_like(input)
         input3d = input.flatten(start_dim=2)
         output3d = output.view_as(input3d)

mmcv/parallel/data_container.py

@@ -60,7 +60,7 @@ def data(self):
     @property
     def datatype(self):
         if isinstance(self.data, torch.Tensor):
-            return self.data.type()
+            return self.data.scalar_type()
         else:
             return type(self.data)
 

mmcv/runner/dist_utils.py

@@ -149,7 +149,7 @@ def _allreduce_coalesced(tensors, world_size, bucket_size_mb=-1):
     else:
         buckets = OrderedDict()
         for tensor in tensors:
-            tp = tensor.type()
+            tp = tensor.scalar_type()
             if tp not in buckets:
                 buckets[tp] = []
             buckets[tp].append(tensor)

tests/test_ops/test_corner_pool.py

@@ -30,29 +30,29 @@ def test_corner_pool_device_and_dtypes_cpu():
                                   [0, 0, 0, 0, 0]]]])
     pool = CornerPool('left')
     left_tensor = pool(lr_tensor)
-    assert left_tensor.type() == lr_tensor.type()
+    assert left_tensor.scalar_type() == lr_tensor.scalar_type()
     assert torch.equal(left_tensor, left_answer)
     # Right Pool
     right_answer = torch.tensor([[[[0, 0, 0, 0, 0], [2, 2, 3, 3, 3],
                                    [5, 5, 5, 5, 6], [0, 0, 0, 0, 0],
                                    [0, 0, 0, 0, 0]]]])
     pool = CornerPool('right')
     right_tensor = pool(lr_tensor)
-    assert right_tensor.type() == lr_tensor.type()
+    assert right_tensor.scalar_type() == lr_tensor.scalar_type()
     assert torch.equal(right_tensor, right_answer)
     # Top Pool
     top_answer = torch.tensor([[[[0, 3, 4, 0, 0], [0, 3, 4, 0, 0],
                                  [0, 3, 4, 0, 0], [0, 2, 2, 0, 0],
                                  [0, 0, 2, 0, 0]]]])
     pool = CornerPool('top')
     top_tensor = pool(tb_tensor)
-    assert top_tensor.type() == tb_tensor.type()
+    assert top_tensor.scalar_type() == tb_tensor.scalar_type()
     assert torch.equal(top_tensor, top_answer)
     # Bottom Pool
     bottom_answer = torch.tensor([[[[0, 3, 1, 0, 0], [0, 3, 1, 0, 0],
                                     [0, 3, 4, 0, 0], [0, 3, 4, 0, 0],
                                     [0, 3, 4, 0, 0]]]])
     pool = CornerPool('bottom')
     bottom_tensor = pool(tb_tensor)
-    assert bottom_tensor.type() == tb_tensor.type()
+    assert bottom_tensor.scalar_type() == tb_tensor.scalar_type()
     assert torch.equal(bottom_tensor, bottom_answer)