20200319 Merge fbcode updates (pytorch#82)

cpuhrsch · web-flow · commit 18b2af5cf4dc · 2020-03-19T18:59:08.000-04:00
diff --git a/benchmarks/basic.py b/benchmarks/basic.py
@@ -7,13 +7,13 @@
 def gen_list_nested_tensor_construction():
     tensors = [torch.rand(random.randint(500, 1500), 25600) for _ in range(20)]
     def _algorithm():
-        nt = torch._ListNestedTensor(tensors)
+        torch._ListNestedTensor(tensors)
     return _algorithm
 
 def gen_list_nested_tensor_unbind():
     nested_tensor = torch._ListNestedTensor([torch.rand(random.randint(500, 1500), 25600) for _ in range(20)])
     def _algorithm():
-        ts = nested_tensor.unbind()
+        nested_tensor.unbind()
     return _algorithm
 
 if __name__ == "__main__":
diff --git a/benchmarks/jit_apply.py b/benchmarks/jit_apply.py
@@ -42,11 +42,11 @@ def gen_jit():
 
     def gen_my_fun(scalar, tensor):
         @torch.jit.ignore
-        def get_scalar() -> float:
+        def get_scalar():
             return scalar
 
         @torch.jit.ignore
-        def get_tensor() -> torch.Tensor:
+        def get_tensor():
             return tensor
 
         @torch.jit.script
diff --git a/benchmarks/nearest_neighbors.py b/benchmarks/nearest_neighbors.py
@@ -104,7 +104,6 @@ def print_results(results, keys, sub_clusters, print_details=False):
 
 def benchmark_fn(fn, run_time = 15.0):
     times = []
-    num_runs = 0
     fn()
     t = 0.0
     while (t < run_time):
diff --git a/benchmarks/utils.py b/benchmarks/utils.py
@@ -18,7 +18,6 @@ def gen_tensor():
 
 def benchmark_fn(fn, run_time = 5.0, use_cprofile=False, warmup=1.0):
     times = []
-    num_runs = 0
     t = 0.0
     pr = cProfile.Profile()
     cuda_avail = torch.cuda.is_available()
diff --git a/nestedtensor/csrc/py_init.cpp b/nestedtensor/csrc/py_init.cpp
@@ -46,9 +46,11 @@ PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
           py::overload_cast<c10::optional<int64_t>>(
               &THPNestedTensor::nested_stride))
       .def("__getitem__", py::overload_cast<int64_t>(&THPNestedTensor::getitem))
+#if (PYBIND11_VERSION_MAJOR == 2 && PYBIND11_VERSION_MINOR >= 4)
       .def(
           "__getitem__",
           py::overload_cast<py::slice>(&THPNestedTensor::getitem))
+#endif
       .def(
           "unbind",
           torch::wrap_pybind_function([](THPNestedTensor self, int64_t dim) {
diff --git a/nestedtensor/csrc/python_nested_tensor.h b/nestedtensor/csrc/python_nested_tensor.h
@@ -51,10 +51,12 @@ struct THPNestedTensor {
   pybind11::object getitem(int64_t key) {
     return unbind(0)[key];
   }
+#if (PYBIND11_VERSION_MAJOR == 2 && PYBIND11_VERSION_MINOR >= 4)
   pybind11::object getitem(py::slice key) {
     py::list unbound = py::cast(unbind(0));
     return unbound[key];
   }
+#endif
   std::vector<pybind11::object> unbind(int64_t dim);
   THPIValueNode nested_size();
   THPIValueNode nested_stride();
diff --git a/nestedtensor/nested/functions.py b/nestedtensor/nested/functions.py
@@ -15,6 +15,8 @@
 
 from nestedtensor import _C
 
+from numbers import Number
+
 orig_squeeze = torch.squeeze
 
 
@@ -161,7 +163,7 @@ def batch_norm(input, running_mean, running_var, weight=None, bias=None, trainin
             input_buffer, running_mean, running_var, weight, bias, training, momentum, eps)
         return nested.NestedTensor(_C._BufferNestedTensor(result.flatten(), input.nested_size()))
 
-    def t_batch_norm(input: torch.Tensor, running_mean: torch.Tensor, running_var: torch.Tensor, weight, bias, training, momentum, eps):
+    def t_batch_norm(input, running_mean, running_var, weight, bias, training, momentum, eps):
         squeeze_after = False
         # TODO: Need support for BatchNorm1d and BatchNorm2d as well
         if input.dim() == 3:
@@ -233,7 +235,7 @@ def interpolate(input, size=None, scale_factor=None, mode='nearest',
     if utils.find_nested_tensor_dispatch_key(input) is None:
         return orig_interpolate(input, size, scale_factor, mode, align_corners)
 
-    def _interpolate(input: torch.Tensor, size: int, scale_factor: float, mode: str, align_corners: bool) -> torch.Tensor:
+    def _interpolate(input, size, scale_factor, mode, align_corners):
         # TODO: Document this
         squeeze_after = False
         if input.dim() == 3:
@@ -269,10 +271,9 @@ def mm(*args, **kwargs):
             self.nested_size(), self.dim() - 1, result.size(-1))
         buffer_ = result.flatten()
         return nested.NestedTensor(
-            _C._BufferNestedTensor(buffer_,
-                                           result_nested_size))
+            _C._BufferNestedTensor(buffer_, result_nested_size))
 
-    tf = utils.tensorwise()(getattr(torch.Tensor, 'mm'))
+    tf = utils.tensorwise()(torch.Tensor.mm)
     return tf(*args, **kwargs)
 
 
diff --git a/nestedtensor/nested/masking.py b/nestedtensor/nested/masking.py
@@ -78,7 +78,9 @@ def _merge(tensors, nested_dim):
         return creation.nested_tensor(inner_tensors)
 
 # Get max size per each dimension from all the passed tensors.
-def get_max_size(obj, res=[1]):
+def get_max_size(obj, res=None):
+    if res is None:
+        res = [1]
     if isinstance(obj, list) or isinstance(obj, tuple):
         for o in obj:
             res = get_max_size(o, res)
@@ -138,7 +140,7 @@ def pad_nt(nt, shape):
 # Return a tuple of a tensor and a mask that represent the given tensor list
 # Returned tensor is always the same no matter what mask_dim was passed.
 # If mask_dim was not passed, a mask with the smallest dimensionality would be returned.
-# if passed mask_dim is lower than the minimal dimensionality of the mask that can represent 
+# if passed mask_dim is lower than the minimal dimensionality of the mask that can represent
 # the data tensor, an error is thrown.
 def to_tensor_mask(nt, mask_dim):
     if mask_dim is not None and mask_dim > nt.dim():
diff --git a/nestedtensor/nested/monkey_patch.py b/nestedtensor/nested/monkey_patch.py
@@ -5,9 +5,6 @@ def monkey_patch(NestedTensor):
     of the torch.Tensor or torch module corresponding implementations.
     """
 
-    import os
-    DEBUG = int(os.getenv("DEBUG", 0))
-
     from nestedtensor.nested import codegen
     from nestedtensor.nested import functions
     import torch
@@ -248,7 +245,6 @@ def new_fn(self):
 
     # module.NestedTensor = NestedTensor
 
-    setattr(NestedTensor, '_NestedTensor__function_dispatch', function_dispatch)
-    setattr(NestedTensor, '_NestedTensor__jit_function_dispatch',
-            jit_function_dispatch)
-    setattr(NestedTensor, '_NestedTensor__C_functions', C_functions)
+    NestedTensor._NestedTensor__function_dispatch = function_dispatch
+    NestedTensor._NestedTensor__jit_function_dispatch = jit_function_dispatch
+    NestedTensor._NestedTensor__C_functions = C_functions
diff --git a/nestedtensor/nested/utils.py b/nestedtensor/nested/utils.py
@@ -218,7 +218,7 @@ def _get_tensortype_args(args, kwargs):
     for a in args:
         if is_nested_tensor(a) or torch.is_tensor(a):
             tt_args.append(a)
-    for k, v in kwargs.items():
+    for _, v in kwargs.items():
         if is_nested_tensor(v) or torch.is_tensor(v):
             tt_args.append(v)
     return tt_args
@@ -229,7 +229,7 @@ def _get_nestedtensor_args(args, kwargs):
     for a in args:
         if is_nested_tensor(a):
             nt_args.append(a)
-    for k, v in kwargs.items():
+    for _, v in kwargs.items():
         if is_nested_tensor(v):
             nt_args.append(v)
     return nt_args
diff --git a/nestedtensor/version.py b/nestedtensor/version.py
@@ -1,5 +1,5 @@
-__version__ = '0.0.1.dev202031816+955d513'
-git_version = '955d5138490c9cb16d0b3cbad6fa444a30ecb31c'
+__version__ = '0.0.1.dev202031922+fbca93b'
+git_version = 'fbca93bae69956e674d061972dd1a3e23e6e0eea'
 from nestedtensor import _C
 if hasattr(_C, 'CUDA_VERSION'):
     cuda = _C.CUDA_VERSION
diff --git a/setup.py b/setup.py
@@ -7,6 +7,7 @@
 import glob
 import subprocess
 import sys
+import io
 
 from torch.utils.cpp_extension import CppExtension, CUDAExtension, CUDA_HOME, BuildExtension
 
@@ -19,13 +20,6 @@ def read(*names, **kwargs):
         return fp.read()
 
 
-def get_dist(pkgname):
-    try:
-        return get_distribution(pkgname)
-    except DistributionNotFound:
-        return None
-
-
 latest_release = "0.0.1"
 
 dt = datetime.datetime.utcnow()
diff --git a/test/test_nested_tensor_autograd.py b/test/test_nested_tensor_autograd.py
@@ -7,22 +7,21 @@
 import unittest
 import random
 
-import utils
 from utils import TestCase
 
 class TestNestedTensorAutograd(TestCase):
     def test_basic_grad(self):
         def some_func(x):
             return torch.sum(x ** 2 + x ** 3)
-        
+
         # single tensor case for comparison
         verification_tensor = torch.tensor([[1, 2], [3, 4]], dtype=torch.float, requires_grad=True)
         sum_res = some_func(verification_tensor)
         sum_res.backward()
 
         # as_nested_tensor constructor
         tensor = torch.tensor([[1, 2], [3, 4]], dtype=torch.float, requires_grad=True)
-        nt = nestedtensor.as_nested_tensor([tensor]) 
+        nt = nestedtensor.as_nested_tensor([tensor])
         nt_sum_res = some_func(nt)
         nt_sum_res.backward()
         self.assertEqual(sum_res, nt_sum_res)
@@ -31,7 +30,7 @@ def some_func(x):
 
         # nested_tensor constructor
         tensor2 = torch.tensor([[1, 2], [3, 4]], dtype=torch.float, requires_grad=True)
-        nt2 = nestedtensor.nested_tensor([tensor2]) 
+        nt2 = nestedtensor.nested_tensor([tensor2])
         nt_sum_res2 = some_func(nt2)
         nt_sum_res2.backward()
         self.assertEqual(sum_res, nt_sum_res2)
@@ -47,14 +46,14 @@ def some_func(x):
                                              torch.tensor([1, 2], dtype=torch.float, requires_grad=True)])
         nt_sum_res = some_func(nt1)
         nt_sum_res.backward()
-        
+
         nt2 = nestedtensor.as_nested_tensor([torch.tensor([1, 2, 3, 4], dtype=torch.float, requires_grad=True),
                                              torch.tensor([1, 2, 3], dtype=torch.float, requires_grad=True),
                                              torch.tensor([1, 2], dtype=torch.float, requires_grad=True)])
         tensor, mask = nt2.to_tensor_mask(mask_dim=2)
         sum_res = some_func(tensor)
         sum_res.backward()
-        
+
         self.assertEqual(sum_res, nt_sum_res)
         self.assertEqual(nt1[0].grad.data, tensor.grad[0].data)
         self.assertEqual(nt1[1].grad.data, tensor.grad[1].data.masked_select(mask[1]))
@@ -90,7 +89,7 @@ def some_func(x):
 
         nt = nestedtensor.nested_tensor_from_tensor_mask(nt_tensor, nt_mask)
         self.assertEqual(True, nt.requires_grad)
-        
+
         nt_sum_res = some_func(nt)
         nt_sum_res.backward()
 
diff --git a/test/test_nested_tensor_buffer.py b/test/test_nested_tensor_buffer.py
@@ -9,7 +9,6 @@
 import random
 
 
-import utils
 
 # TODO: Test unbind, test grad and backward
 
diff --git a/test/test_nested_tensor_class.py b/test/test_nested_tensor_class.py
@@ -38,8 +38,8 @@ def test_nested_constructor(self):
         for constructor in _iter_constructors():
             num_nested_tensor = 3
             # TODO: Shouldn't be constructable
-            nested_tensors = [utils.gen_nested_tensor(i, i, 3, constructor=constructor)
-                              for i in range(1, num_nested_tensor)]
+            [utils.gen_nested_tensor(i, i, 3, constructor=constructor)
+             for i in range(1, num_nested_tensor)]
 
     def test_list_constructor(self):
         """
@@ -564,7 +564,7 @@ def test_pin_memory(self):
 
 class TestContiguous(TestCase):
     def test_contiguous(self):
-        for i in range(1, 10):
+        for _ in range(1, 10):
             # data = gen_nested_list(1, 2, 3, size_low=1, size_high=3)
             data = [[torch.rand(1, 2), torch.rand(3, 4)], [torch.rand(5, 6)]]
             nt = nestedtensor.nested_tensor(data)
diff --git a/test/test_nested_tensor_functional.py b/test/test_nested_tensor_functional.py
@@ -12,12 +12,12 @@
 class TestFunctional(TestCase):
 
     def test_nll_loss(self):
-        a = utils.gen_float_tensor(1, (40, 5))
-        b = utils.gen_float_tensor(1, (40,))
+        utils.gen_float_tensor(1, (40, 5))
+        utils.gen_float_tensor(1, (40,))
 
     def test_addmm(self):
-        a, b = torch.rand(5), torch.rand(4, 5)
-        nt = nestedtensor.nested_tensor(
+        torch.rand(5), torch.rand(4, 5)
+        nestedtensor.nested_tensor(
             [torch.rand(1, 4), torch.rand(1, 4), torch.rand(4, 4)])
 
     def test_conv2d(self):
diff --git a/test/test_nested_tensor_masking.py b/test/test_nested_tensor_masking.py
diff --git a/test/test_nested_tensor_nary.py b/test/test_nested_tensor_nary.py
diff --git a/test/test_nested_tensor_tensorwise.py b/test/test_nested_tensor_tensorwise.py
diff --git a/test/utils.py b/test/utils.py
diff --git a/test/utils_test_case.py b/test/utils_test_case.py

Original file line number	Diff line number	Diff line change
`@@ -51,10 +51,12 @@ struct THPNestedTensor {`
`51`	`51`	`pybind11::object getitem(int64_t key) {`
`52`	`52`	`return unbind(0)[key];`
`53`	`53`	`}`
	`54`	`+#if (PYBIND11_VERSION_MAJOR == 2 && PYBIND11_VERSION_MINOR >= 4)`
`54`	`55`	`pybind11::object getitem(py::slice key) {`
`55`	`56`	`py::list unbound = py::cast(unbind(0));`
`56`	`57`	`return unbound[key];`
`57`	`58`	`}`
	`59`	`+#endif`
`58`	`60`	`std::vector<pybind11::object> unbind(int64_t dim);`
`59`	`61`	`THPIValueNode nested_size();`
`60`	`62`	`THPIValueNode nested_stride();`