Throws runtime error when torch.full would infer a float dtype from a bool or integral fill value (pytorch#40364)

Summary:
BC-breaking NOTE:

In PyTorch 1.6 bool and integral fill values given to torch.full must set the dtype our out keyword arguments. In prior versions of PyTorch these fill values would return float tensors by default, but in PyTorch 1.7 they will return a bool or long tensor, respectively. The documentation for torch.full has been updated to reflect this.

PR NOTE:

This PR causes torch.full to throw a runtime error when it would have inferred a float dtype by being given a boolean or integer value. A versioned symbol for torch.full is added to preserve the behavior of already serialized Torchscript programs. Existing tests for this behavior being deprecated have been updated to reflect it now being unsupported, and a couple new tests have been added to validate the versioned symbol behavior. The documentation of torch.full has also been updated to reflect this change.
Pull Request resolved: pytorch#40364

Differential Revision: D22176640

Pulled By: mruberry

fbshipit-source-id: b20158ebbcb4f6bf269d05a688bcf4f6c853a965

Author: Mike Ruberry

aten/src/ATen/native/TensorFactories.cpp

@@ -355,13 +355,12 @@ TensorOptions infer_full_options(
 
   if (!options.has_dtype()) {
     if (fill_value.isIntegral(true)) {
-      TORCH_WARN_ONCE(
-        "Deprecation warning: In a future PyTorch release torch.full ",
-        "will no longer return tensors of floating dtype by default. ",
-        "Instead, a bool fill_value will return a tensor of torch.bool dtype, ",
-        "and an integral fill_value will return a tensor of torch.long dtype. ",
-        "Set the optional `dtype` or `out` arguments to suppress this warning."
-      );
+      TORCH_CHECK(false,
+        "Providing a bool or integral fill value without setting the optional ",
+        "`dtype` or `out` arguments is currently unsupported. In PyTorch 1.7, ",
+        "when `dtype` and `out` are not set a bool fill value will ",
+        "return a tensor of torch.bool dtype, and an integral fill value ",
+        "will return a tensor of torch.long dtype.");
     } else if (fill_value.isComplex()) {
       auto scalar_type = (get_default_dtype() == ScalarType::Double) ?
                             ScalarType::ComplexDouble :

caffe2/serialize/inline_container.h

@@ -99,9 +99,9 @@ constexpr uint64_t kMaxSupportedFileFormatVersion = 0x5L;
 // 3. Added type tags to pickle serialization of container types
 // 4. Stopped integer division using torch.div
 //      (a versioned symbol preserves the historic behavior of versions 1--3)
-// 5. (Read-only) Stops torch.full inferring a floating point dtype
-//      when given integer fill values.
-constexpr uint64_t kProducedFileFormatVersion = 0x4L;
+// 5. Stops torch.full inferring a floating point dtype
+//      when given bool or integer fill values.
+constexpr uint64_t kProducedFileFormatVersion = 0x5L;
 
 // Writer-specific constants
 constexpr uint64_t kFieldAlignment = 64;

test/cpp/api/autograd.cpp

@@ -193,7 +193,7 @@ TEST(CustomAutogradTest, FunctionReturnsInput) {
 
   Variable x(torch::ones(1, torch::requires_grad()));
   MyFunction::apply(x).backward(torch::ones(1) , true, true);
-  ASSERT_VARIABLE_EQ(x.grad(), torch::full(1,2));
+  ASSERT_VARIABLE_EQ(x.grad(), torch::full(1, 2.));
 }
 
 TEST(CustomAutogradTest, NoGradCustomFunction) {

test/distributed/test_c10d.py

@@ -1528,9 +1528,9 @@ def test_round_robin(self):
 
         # Run a few collectives so that we have called each process group
         for _ in range(num_process_groups + 1):
-            tensor = torch.full([100, 100], self.rank)
+            tensor = torch.full([100, 100], float(self.rank))
             pg.broadcast(tensor, root=0).wait()
-            self.assertEqual(torch.full([100, 100], 0), tensor)
+            self.assertEqual(torch.full([100, 100], 0.), tensor)
 
     def test_round_robin_create_destroy(self):
         store = c10d.FileStore(self.file_name, self.world_size)
@@ -1551,7 +1551,7 @@ def create(num, prefix):
             for _ in range(3):
                 tensor = torch.ones([10, 10])
                 pg.allreduce(tensor).wait()
-                self.assertEqual(torch.full([10, 10], self.world_size), tensor)
+                self.assertEqual(torch.full([10, 10], float(self.world_size)), tensor)
             del pg
 
 

test/jit/fixtures/test_versioned_full_integer_value_v4.pt

@@ -480,6 +480,78 @@ def _helper(m, fn):
 
         _helper(v3_module, current_module)
 
+    # NOTE: the JIT was incapable of handling boolean fill values when
+    #   PyTorch produced file format versions 0-4
+    def test_versioned_full_integer_value(self):
+        class MyModule(torch.nn.Module):
+            def __init__(self):
+                super(MyModule, self).__init__()
+
+            def forward(self, int_fill: int):
+                size = torch.Size(2, 2)
+                a = torch.full(size, int_fill)
+                b = torch.full(size, 1)
+                return (a, b)
+
+        try:
+            v4_module = torch.jit.load(pytorch_test_dir + "/jit/fixtures/test_versioned_full_integer_value_v4.pt")
+        except Exception as e:
+            self.skipTest("Failed to load fixture!")
+
+        self._verify_count("aten::full", v4_module, 2)
+
+        current_module = self._save_load_module(MyModule)
+        self._verify_count("aten::full", current_module, 2)
+
+        # Verifies historic integer type inference is float
+        # NOTE: only verifies floating point, not exact dtype, due to
+        #   https://github.com/pytorch/pytorch/issues/40470
+        results = v4_module(2)
+        for result in results:
+            self.assertTrue(result.is_floating_point())
+
+        # Verifies values are correct
+        a, b = results
+        self.assertTrue((a == 2.).all())
+        self.assertTrue((b == 1.).all())
+
+        with self.assertRaisesRegex(RuntimeError, ".+is currently unsupported.+"):
+            current_module(2)
+
+    # Tests that torch.full behavior which is the same from prior versions
+    #   to version 5 is preserved.
+    # NOTE: while torch.full in eager PyTorch accepts a requires_grad argument,
+    #   it does not in Torchscript (see https://github.com/pytorch/pytorch/issues/40363)
+    def test_versioned_full_preserved(self):
+        class MyModule(torch.nn.Module):
+            def __init__(self):
+                super(MyModule, self).__init__()
+
+            def forward(self, float_fill: float):
+                size = (2, 2)
+                a = torch.full(size, 1.)
+                b = torch.full(size, float_fill)
+                c = torch.full(size, float_fill, dtype=torch.long)
+
+                out = torch.empty(size, dtype=torch.long)
+                d = torch.full(size, float_fill, out=out)
+
+                e = torch.full(size, float_fill, dtype=torch.float16, pin_memory=None,
+                               layout=torch.strided, device='cpu')
+                return (a, b, c, d, e)
+
+        try:
+            v4_module = torch.jit.load(pytorch_test_dir + "/jit/fixtures/test_versioned_full_preserved_v4.pt")
+        except Exception as e:
+            self.skipTest("Failed to load fixture!")
+
+        self._verify_count("aten::full", v4_module, 5)
+
+        current_module = self._save_load_module(MyModule)
+        self._verify_count("aten::full", current_module, 5)
+
+        self.assertEqual(v4_module(2.), current_module(2.))
+
     def test_versioned_symbols_reserialization(self):
         """
         Tests that loading and saving serialized Torchscript with a versioned

test/jit/fixtures/test_versioned_full_preserved_v4.pt

@@ -390,7 +390,7 @@ def test_trace_arange_with_grad(self):
     # Test that a trace of torch.full(x.shape) doesn't store the shape as a constant
     def test_trace_full_dynamic_shape(self):
         def full_with_shape_like(x):
-            return torch.full(x.shape, 2)
+            return torch.full(x.shape, 2.)
 
         x = torch.randn(3, 4)
         ge = torch.jit.trace(full_with_shape_like, example_inputs=x)

test/jit/test_save_load.py

@@ -252,10 +252,9 @@ def forward(self, x):
 
         ops = [{"op_name" : "Constant"},
                {"op_name" : "ConstantOfShape"},
-               {"op_name" : "Cast"},
                {"op_name" : "Add"}]
         ops = {9 : ops, 10 : ops}
-        x = torch.tensor(12)
+        x = torch.tensor(12.)
         check_onnx_opsets_operator(MyModule(), x, ops, opset_versions=[9, 10])
 
     def test_interpolate(self):

test/jit/test_tracer.py

@@ -356,7 +356,7 @@ def test_hardtanh(self):
 
     def test_full(self):
         x = torch.randn(3, 4, requires_grad=True)
-        self.assertONNX(lambda x: torch.full(x.shape, 2), x)
+        self.assertONNX(lambda x: torch.full(x.shape, 2.), x)
 
     def test_full_like(self):
         x = torch.randn(3, 4, requires_grad=True)

test/onnx/test_onnx_opset.py

@@ -1895,7 +1895,7 @@ def get_LstmNet_model_and_inputs(num_layers, bidirectional):
 
         num_layers = [1, 1, 2, 3]
         bidirectional = [True, False, True, False]
-        models_and_inputs = [get_LstmNet_model_and_inputs(n, b) for n, b in zip(num_layers, bidirectional)] 
+        models_and_inputs = [get_LstmNet_model_and_inputs(n, b) for n, b in zip(num_layers, bidirectional)]
         for model, input in models_and_inputs:
             self.run_test(model, input)
 
@@ -1960,7 +1960,7 @@ def get_GruNet_model_and_inputs(input_size, hidden_size, num_layers, batch_size,
         num_layers = [2, 3]
         batch_size = [3, 4]
         seq_len = [5, 7]
-        bidirectional = [True, False] 
+        bidirectional = [True, False]
         models_and_inputs = [get_GruNet_model_and_inputs(i, h, n, b, s, bi)
                              for i, h, n, b, s, bi in zip(input_size, hidden_size, num_layers, batch_size, seq_len, bidirectional)]
         for model, input in models_and_inputs:
@@ -2684,7 +2684,7 @@ class FullModel(torch.nn.Module):
             # add is used for exporting full
             def forward(self, x):
                 return torch.full((3, 4), x)
-        x = torch.tensor(12)
+        x = torch.tensor(12.)
         self.run_test(FullModel(), x)
 
     def test_l1_norm(self):

test/onnx/test_operators.py

@@ -158,12 +158,12 @@ def backward(ctx, grad):
         for shape in [(1,), ()]:
             v = torch.ones(shape, requires_grad=True)
             MyFunction.apply(v).backward()
-            self.assertEqual(v.grad, torch.full(shape, 2))
+            self.assertEqual(v.grad, torch.full(shape, 2.))
 
             with torch.no_grad():
                 v.grad.zero_()
             MyFunction.apply(v.clone()).backward()
-            self.assertEqual(v.grad, torch.full(shape, 2))
+            self.assertEqual(v.grad, torch.full(shape, 2.))
 
     def test_legacy_function_deprecation_exception(self):
         # Trigger exception

test/onnx/test_pytorch_onnx_onnxruntime.py

@@ -406,7 +406,7 @@ def test_cuda_memory_allocation(self):
         for _ in range(5):
             t.append(q.get())
         # TODO(#38095): Replace assertEqualIgnoreType. See issue #38095
-        self.assertEqualIgnoreType(t[0], torch.full([5], 0))
+        self.assertEqualIgnoreType(t[0], torch.full([5], 0.))
         del t
         e.set()
         p.join(1)

test/test_autograd.py

@@ -459,8 +459,8 @@ def _test(factory, device):
         # Test torch.full
         for device in torch.testing.get_all_device_types():
             names = ('N', 'T', 'D')
-            result = torch.full([1, 2, 3], 2, names=names, device=device)
-            expected = torch.full([1, 2, 3], 2, device=device).rename_(*names)
+            result = torch.full([1, 2, 3], 2., names=names, device=device)
+            expected = torch.full([1, 2, 3], 2., device=device).rename_(*names)
             self.assertTensorDataAndNamesEqual(result, expected)
 
     def test_tensor_from_lists(self):
@@ -1388,7 +1388,7 @@ def test_as_strided_cuda(self):
 
     def test_no_jit_tracer_support(self):
         def foo(x):
-            return torch.full(x.shape, 2, names=('N',))
+            return torch.full(x.shape, 2., names=('N',))
 
         with self.assertRaisesRegex(RuntimeError, 'not supported with the tracer'):
             x = torch.randn(3)

test/test_multiprocessing.py

@@ -13089,9 +13089,9 @@ def test_reduction_empty(self, device):
             ('mode', torch.mode, None),
             ('median', torch.median, None),
 
-            ('prod', torch.prod, 1),
-            ('sum', torch.sum, 0),
-            ('norm', torch.norm, 0),
+            ('prod', torch.prod, 1.),
+            ('sum', torch.sum, 0.),
+            ('norm', torch.norm, 0.),
             ('mean', torch.mean, nan),
             ('var', torch.var, nan),
             ('std', torch.std, nan),
@@ -17303,25 +17303,26 @@ def test_min_mixed_devices(self, device):
             self.assertRaises(RuntimeError,
                               lambda: torch.min(a, 0, out=(values, indices)))
 
-    def test_full_deprecation_warning(self, device):
+    # NOTE: inferring the dtype from bool or integer fill values is
+    #   disabled because the behavior is changing from PyTorch 1.5,
+    #   where the default scalar type would be inferred, to PyTorch 1.7,
+    #   where bool or long, respectively, will be inferred.
+    def test_full_unsupported_integer_inference(self, device):
         size = (2, 2)
         # Tests bool and integer fill_values deprecated without specific dtype set
-        with self.maybeWarnsRegex(UserWarning, 'Deprecation warning: .+'):
+        with self.assertRaisesRegex(RuntimeError, '.+is currently unsupported.+'):
             self.assertEqual(torch.full(size, True).dtype, torch.float)
-        with self.maybeWarnsRegex(UserWarning, 'Deprecation warning: .+'):
+        with self.assertRaisesRegex(RuntimeError, '.+is currently unsupported.+'):
             self.assertEqual(torch.full(size, 1).dtype, torch.float)
 
         # Explicitly setting the dtype doesn't warn
-        with self.maybeWarnsRegex(UserWarning, ''):
-            self.assertEqual(torch.full(size, 1, dtype=torch.long).dtype, torch.long)
-        with self.maybeWarnsRegex(UserWarning, ''):
-            self.assertEqual(torch.full(size, True, dtype=torch.bool).dtype,
-                             torch.bool)
+        self.assertEqual(torch.full(size, 1, dtype=torch.long).dtype, torch.long)
+        self.assertEqual(torch.full(size, True, dtype=torch.bool).dtype, torch.bool)
 
         # Performs same tests with named tensor
-        with self.maybeWarnsRegex(UserWarning, 'Deprecation warning: .+|Named tensors .+'):
+        with self.assertRaisesRegex(RuntimeError, '.+is currently unsupported.+'):
             self.assertEqual(torch.full(size, True, names=('a', 'b')).dtype, torch.float)
-        with self.maybeWarnsRegex(UserWarning, 'Deprecation warning: .+|Named tensors .+'):
+        with self.assertRaisesRegex(RuntimeError, '.+is currently unsupported.+'):
             self.assertEqual(torch.full(size, 1, names=('a', 'b')).dtype, torch.float)
 
         with self.maybeWarnsRegex(UserWarning, 'Named tensors .+'):
@@ -17339,15 +17340,17 @@ def test_full_inference(self, device, dtype):
         prev_default = torch.get_default_dtype()
         torch.set_default_dtype(dtype)
 
-        # Tests bool fill value inference
+        # Tests bool fill value inference (currently unsupported)
         # Note: in the future this will return a tensor of torch.bool dtype
-        t = torch.full(size, True)
-        self.assertEqual(t.dtype, dtype)
+        with self.assertRaisesRegex(RuntimeError, '.+is currently unsupported.+'):
+            t = torch.full(size, True)
+            self.assertEqual(t.dtype, dtype)
 
-        # Tests integer fill value inference
+        # Tests integer fill value inference (currently unsupported)
         # Note: in the future this will return a tensor of torch.long dtype
-        t = torch.full(size, 1)
-        self.assertEqual(t.dtype, dtype)
+        with self.assertRaisesRegex(RuntimeError, '.+is currently unsupported.+'):
+            t = torch.full(size, 1)
+            self.assertEqual(t.dtype, dtype)
 
         # Tests float fill value inference
         t = torch.full(size, 1.)
@@ -17372,14 +17375,16 @@ def test_full_like_inference(self, device):
                          torch.complex64)
 
     def test_full_out(self, device):
-        o = torch.empty((5,), device=device, dtype=torch.long)
+        size = (5,)
+        o = torch.empty(size, device=device, dtype=torch.long)
 
         # verifies dtype/out conflict throws a RuntimeError
         with self.assertRaises(RuntimeError):
             torch.full(o.shape, 1., dtype=torch.float, out=o)
 
         # verifies out dtype overrides inference
         self.assertEqual(torch.full(o.shape, 1., out=o).dtype, o.dtype)
+        self.assertEqual(torch.full(size, 1, out=o).dtype, o.dtype)
 
     def _float_to_int_conversion_helper(self, vals, device, dtype):
         assert TEST_NUMPY

test/test_namedtensor.py

@@ -6958,9 +6958,9 @@ def merge_dicts(*dicts):
 Returns a tensor of size :attr:`size` filled with :attr:`fill_value`.
 
 .. warning::
-    In PyTorch 1.5 a bool or integral :attr:`fill_value` will produce a warning if
-    :attr:`dtype` or :attr:`out` are not set.
-    In a future PyTorch release, when :attr:`dtype` and :attr:`out` are not set
+    Providing a bool or integral :attr:`fill_value` without setting
+    the optional :attr:`dtype` or :attr:`out` arguments is currently unsupported.
+    In PyTorch 1.7, when :attr:`dtype` and :attr:`out` are not set
     a bool :attr:`fill_value` will return a tensor of torch.bool dtype,
     and an integral :attr:`fill_value` will return a tensor of torch.long dtype.
 

test/test_torch.py

@@ -127,6 +127,28 @@ def div__0_3(self: Tensor, other: number) -> Tensor:
   return self.floor_divide_(other)
 )SCRIPT";
 
+// NOTE: torch.full would historically infer a float dtype for bool and
+//   integral fill values.
+// NOTE: Torchscript does not currently support complex values
+// NOTE: Torchscript does not currently support named tensors, although
+//   torch.full does have a named tensor variant
+auto full = R"SCRIPT(
+def full_0_4(size:List[int], fill_value:number, *, dtype:Optional[int]=None,
+             layout:Optional[int]=None, device:Optional[Device]=None,
+             pin_memory:Optional[bool]=None) -> Tensor:
+  if dtype is None:
+    fill_value = float(fill_value)
+
+  return torch.full(size, fill_value, dtype=dtype, layout=layout, device=device, pin_memory=pin_memory)
+)SCRIPT";
+
+// NOTE: the out variant of full works the same, but must be overridden
+//   since the other variant of full is overridden
+auto full_out = R"SCRIPT(
+def full_0_4(size:List[int], fill_value:number, *, out:Tensor) -> Tensor:
+  return torch.full(size, fill_value, out=out)
+)SCRIPT";
+
 struct BuiltinFunctionRegistry {
   const std::vector<Function*>& getAllBuiltinFunctionsFor(Symbol name) {
     const static std::vector<Function*> empty;
@@ -204,6 +226,8 @@ struct BuiltinFunctionRegistry {
     loadSource(div__tensor, "upgraders");
     loadSource(div_tensor_out, "upgraders");
     loadSource(div__scalar, "upgraders");
+    loadSource(full, "upgraders");
+    loadSource(full_out, "upgraders");
 
     // These are under `prim` instead of `aten` since they exist to bind certain
     // tensor property getters to correpsonding methods

torch/_torch_docs.py

@@ -72,6 +72,8 @@ static std::unordered_map<Symbol, SymbolRange> symbol_range_map({
      {0, 3, Symbol::fromQualString("upgraders::div_0_3")}},
     {Symbol::fromQualString("aten::div_"),
      {0, 3, Symbol::fromQualString("upgraders::div__0_3")}},
+    {Symbol::fromQualString("aten::full"),
+     {0, 4, Symbol::fromQualString("upgraders::full_0_4")}},
 });
 
 Symbol get_symbol_for_version(const Symbol name, const uint64_t version) {

torch/csrc/jit/frontend/builtin_functions.cpp

@@ -1609,7 +1609,7 @@ def get_int64_dtype(dtype):
 
     default_dtype = torch.get_default_dtype()
     check_value(torch.empty(shape), default_dtype, torch.strided, -1, None, False)
-    check_value(torch.full(shape, -5), default_dtype, torch.strided, -1, None, False)
+    check_value(torch.full(shape, -5.), default_dtype, torch.strided, -1, None, False)
     for dtype in dtypes:
         for rg in {dtype.is_floating_point, False}:
             int64_dtype = get_int64_dtype(dtype)