Throws runtime error on attempted addcdiv integer division (#38762)
Summary:
1.6 Deprecation Note:
In 1.6 attempting to perform integer division using addcdiv will throw a RuntimeError, and in 1.7 the behavior will change so that addcdiv always performs a true division of its tensor1 and tensor2 inputs. See the warning in torch.addcdiv's documentation for more information.
PR Summary:
This PR updates the warning that appears when addcdiv performs integer division to throw a RuntimeError. This is intended to prevent silent errors when torch.addcdiv's behavior is changed to always perform true division in 1.7. The documentation is updated (slightly) to reflect this, as our the addcdiv tests in test_torch and test_type_promotion.
Pull Request resolved: https://github.com/pytorch/pytorch/pull/38762
Differential Revision: D21657585
Pulled By: mruberry
fbshipit-source-id: c514b44409706f2bcfeca4473424b30cc48aafbc
diff --git a/aten/src/ATen/native/PointwiseOps.cpp b/aten/src/ATen/native/PointwiseOps.cpp
index 9366cf4..a9aef8a 100644
--- a/aten/src/ATen/native/PointwiseOps.cpp
+++ b/aten/src/ATen/native/PointwiseOps.cpp
@@ -71,13 +71,13 @@
Scalar value) {
if (isIntegralType(tensor1.scalar_type(), /*includeBool=*/ true)
&& isIntegralType(tensor2.scalar_type(), /*includeBool=*/ true)) {
- TORCH_WARN_ONCE(
- "Integer division with addcdiv is deprecated, and in a future ",
+ TORCH_CHECK(false,
+ "Integer division with addcdiv is no longer supported, and in a future ",
"release addcdiv will perform a true division of tensor1 and tensor2. ",
- "The current addcdiv behavior can be replicated using floor_divide ",
+ "The historic addcdiv behavior can be implemented using floor_divide ",
"for integral inputs (self + value * tensor1 // tensor2) and ",
"division for float inputs (self + value * tensor1 / tensor2). ",
- "The new addcdiv behavior can be implemented with true_divide ",
+ "The future addcdiv behavior can be implemented with true_divide ",
"(self + value * torch.true_divide(tensor1, tensor2).");
}
checkBackend("addcdiv_cpu", result, self.options().backend());
diff --git a/test/test_torch.py b/test/test_torch.py
index deb5fe7..7ed320e 100644
--- a/test/test_torch.py
+++ b/test/test_torch.py
@@ -12823,12 +12823,18 @@
non_zero_rand((2, 2), dtype=dtype, device=device))
for dtype in torch.testing.get_all_math_dtypes(device):
- # CPU complex addcdiv is wildly inaccurate
- if dtype.is_complex and self.device_type == 'cpu':
- with self.assertRaises(AssertionError):
- _helper()
- # CUDA complex addcdiv is not implemented
- elif dtype.is_complex and self.device_type == 'cuda':
+ if dtype.is_complex:
+ # CPU complex addcdiv is wildly inaccurate
+ if self.device_type == 'cpu':
+ with self.assertRaises(AssertionError):
+ _helper()
+
+ # CUDA complex addcdiv is not implemented
+ if self.device_type == 'cuda':
+ with self.assertRaises(RuntimeError):
+ _helper()
+ elif not dtype.is_floating_point:
+ # Integer division with addcdiv is prohibited
with self.assertRaises(RuntimeError):
_helper()
else:
diff --git a/test/test_type_promotion.py b/test/test_type_promotion.py
index 4e752e1..09662d1 100644
--- a/test/test_type_promotion.py
+++ b/test/test_type_promotion.py
@@ -713,11 +713,17 @@
with self.maybeWarnsRegex(UserWarning, '^Integer division.+is deprecated.+'):
torch.div(a, b, out=o)
- # Tests addcdiv deprecation
- with self.maybeWarnsRegex(UserWarning, '^Integer division.+is deprecated.+'):
- torch.addcdiv(a, b, b)
- with self.maybeWarnsRegex(UserWarning, '^Integer division.+is deprecated.+'):
- torch.addcdiv(a, b, b, out=o)
+ @onlyOnCPUAndCUDA
+ @dtypes(torch.int8, torch.uint8, torch.int16, torch.int32, torch.int64)
+ def test_integer_addcdiv_deprecated(self, device, dtype):
+ t = torch.tensor(1, device=device, dtype=dtype)
+
+ with self.assertRaisesRegex(RuntimeError, '^Integer division.+is no longer supported.+'):
+ torch.addcdiv(t, t, t)
+ with self.assertRaisesRegex(RuntimeError, '^Integer division.+is no longer supported.+'):
+ torch.addcdiv(t, t, t, out=t)
+ with self.assertRaisesRegex(RuntimeError, '^Integer division.+is no longer supported+'):
+ t.addcdiv_(t, t)
@unittest.skipIf(not TEST_NUMPY, "NumPy not found")
@dtypes(torch.complex64, torch.complex128)
diff --git a/torch/_torch_docs.py b/torch/_torch_docs.py
index b201acd..e2891fc 100644
--- a/torch/_torch_docs.py
+++ b/torch/_torch_docs.py
@@ -272,14 +272,14 @@
multiply the result by the scalar :attr:`value` and add it to :attr:`input`.
.. warning::
- Integer division with addcdiv is deprecated, and in a future release
+ Integer division with addcdiv is no longer supported, and in a future release
addcdiv will perform a true division of :attr:`tensor1` and :attr:`tensor2`.
- The current addcdiv behavior can be replicated using :func:`floor_divide`
+ The historic addcdiv behavior can be implemented using :func:`floor_divide`
for integral inputs
(:attr:`input` + :attr:`value` * :attr:`tensor1` // :attr:`tensor2`)
and :func:`div` for float inputs
(:attr:`input` + :attr:`value` * :attr:`tensor1` / :attr:`tensor2`).
- The new addcdiv behavior can be implemented with :func:`true_divide`
+ The future addcdiv behavior can be implemented with :func:`true_divide`
(:attr:`input` + :attr:`value` * torch.true_divide(:attr:`tensor1`,
:attr:`tensor2`).
@@ -1416,7 +1416,7 @@
r"""
logcumsumexp(input, dim, out=None) -> Tensor
Returns the logarithm of the cumulative summation of the exponentiation of
-elements of :attr:`input` in the dimension :attr:`dim`.
+elements of :attr:`input` in the dimension :attr:`dim`.
For summation index :math:`j` given by `dim` and other indices :math:`i`, the result is
@@ -7814,15 +7814,15 @@
r"""
searchsorted(sorted_sequence, values, out_int32=False, right=False, out=None) -> Tensor
-Find the indices from the *innermost* dimension of :attr:`sorted_sequence` such that, if the
-corresponding values in :attr:`values` were inserted before the indices, the order of the
-corresponding *innermost* dimension within :attr:`sorted_sequence` would be preserved.
-Return a new tensor with the same size as :attr:`values`. If :attr:`right` is False (default),
-then the left boundary of :attr:`sorted_sequence` is closed. More formally, the returned index
-satisfies the following rules:
+Find the indices from the *innermost* dimension of :attr:`sorted_sequence` such that, if the
+corresponding values in :attr:`values` were inserted before the indices, the order of the
+corresponding *innermost* dimension within :attr:`sorted_sequence` would be preserved.
+Return a new tensor with the same size as :attr:`values`. If :attr:`right` is False (default),
+then the left boundary of :attr:`sorted_sequence` is closed. More formally, the returned index
+satisfies the following rules:
-.. list-table::
- :widths: 12 10 78
+.. list-table::
+ :widths: 12 10 78
:header-rows: 1
* - :attr:`sorted_sequence`
@@ -7842,27 +7842,27 @@
- ``sorted_sequence[m][n]...[l][i-1] < values[m][n]...[l][x] <= sorted_sequence[m][n]...[l][i]``
Args:
- sorted_sequence (Tensor): N-D or 1-D tensor, containing monotonically increasing sequence on the *innermost*
+ sorted_sequence (Tensor): N-D or 1-D tensor, containing monotonically increasing sequence on the *innermost*
dimension.
values (Tensor or Scalar): N-D tensor or a Scalar containing the search value(s).
- out_int32 (bool, optional): indicate the output data type. torch.int32 if True, torch.int64 otherwise.
+ out_int32 (bool, optional): indicate the output data type. torch.int32 if True, torch.int64 otherwise.
Default value is False, i.e. default output data type is torch.int64.
- right (bool, optional): if False, return the first suitable location that is found. If True, return the
- last such index. If no suitable index found, return 0 for non-numerical value
- (eg. nan, inf) or the size of *innermost* dimension within :attr:`sorted_sequence`
- (one pass the last index of the *innermost* dimension). In other words, if False,
- gets the lower bound index for each value in :attr:`values` on the corresponding
- *innermost* dimension of the :attr:`sorted_sequence`. If True, gets the upper
+ right (bool, optional): if False, return the first suitable location that is found. If True, return the
+ last such index. If no suitable index found, return 0 for non-numerical value
+ (eg. nan, inf) or the size of *innermost* dimension within :attr:`sorted_sequence`
+ (one pass the last index of the *innermost* dimension). In other words, if False,
+ gets the lower bound index for each value in :attr:`values` on the corresponding
+ *innermost* dimension of the :attr:`sorted_sequence`. If True, gets the upper
bound index instead. Default value is False.
out (Tensor, optional): the output tensor, must be the same size as :attr:`values` if provided.
-.. note:: If your use case is always 1-D sorted sequence, :func:`torch.bucketize` is preferred,
+.. note:: If your use case is always 1-D sorted sequence, :func:`torch.bucketize` is preferred,
because it has fewer dimension checks resulting in slightly better performance.
Example::
- >>> sorted_sequence = torch.tensor([[1, 3, 5, 7, 9], [2, 4, 6, 8, 10]])
+ >>> sorted_sequence = torch.tensor([[1, 3, 5, 7, 9], [2, 4, 6, 8, 10]])
>>> sorted_sequence
tensor([[ 1, 3, 5, 7, 9],
[ 2, 4, 6, 8, 10]])
@@ -7890,12 +7890,12 @@
bucketize(input, boundaries, out_int32=False, right=False, out=None) -> Tensor
Returns the indices of the buckets to which each value in the :attr:`input` belongs, where the
-boundaries of the buckets are set by :attr:`boundaries`. Return a new tensor with the same size
-as :attr:`input`. If :attr:`right` is False (default), then the left boundary is closed. More
+boundaries of the buckets are set by :attr:`boundaries`. Return a new tensor with the same size
+as :attr:`input`. If :attr:`right` is False (default), then the left boundary is closed. More
formally, the returned index satisfies the following rules:
-.. list-table::
- :widths: 15 85
+.. list-table::
+ :widths: 15 85
:header-rows: 1
* - :attr:`right`
@@ -7908,14 +7908,14 @@
Args:
input (Tensor or Scalar): N-D tensor or a Scalar containing the search value(s).
boundaries (Tensor): 1-D tensor, must contain a monotonically increasing sequence.
- out_int32 (bool, optional): indicate the output data type. torch.int32 if True, torch.int64 otherwise.
+ out_int32 (bool, optional): indicate the output data type. torch.int32 if True, torch.int64 otherwise.
Default value is False, i.e. default output data type is torch.int64.
- right (bool, optional): if False, return the first suitable location that is found. If True, return the
- last such index. If no suitable index found, return 0 for non-numerical value
- (eg. nan, inf) or the size of :attr:`boundaries` (one pass the last index).
- In other words, if False, gets the lower bound index for each value in :attr:`input`
- from :attr:`boundaries`. If True, gets the upper bound index instead.
- Default value is False.
+ right (bool, optional): if False, return the first suitable location that is found. If True, return the
+ last such index. If no suitable index found, return 0 for non-numerical value
+ (eg. nan, inf) or the size of :attr:`boundaries` (one pass the last index).
+ In other words, if False, gets the lower bound index for each value in :attr:`input`
+ from :attr:`boundaries`. If True, gets the upper bound index instead.
+ Default value is False.
out (Tensor, optional): the output tensor, must be the same size as :attr:`input` if provided.
