8000 Updates floor_divide to perform floor division (#78411) · pytorch/pytorch@089203f · GitHub
[go: up one dir, main page]
Skip to content

Commit 089203f

Browse files
Mike Ruberrypytorchmergebot
Mike Ruberry
authored and
pytorchmergebot
committed
Updates floor_divide to perform floor division (#78411)
Fixes #43874 This PR changes floor_divide to perform floor division instead of truncation division. This is a BC-breaking change, but it's a "bug fix," and we've already warned users for several releases this behavior would change. Pull Request resolved: #78411 Approved by: https://github.com/ngimel
1 parent 3ee863c commit 089203f

File tree

9 files changed

+81
-165
lines changed

9 files changed

+81
-165
lines changed

‎aten/src/ATen/native/BinaryOps.cpp

Lines changed: 2 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -674,34 +674,18 @@ Tensor& true_divide_(Tensor& self, const Scalar& divisor) {
674674
}
675675

676676
Tensor& floor_divide_out(const Tensor& self, const Tensor& other, Tensor& result) {
677-
TORCH_WARN_ONCE(
678-
"floor_divide is deprecated, and will be removed in a future version of pytorch. "
679-
"It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). "
680-
"This results in incorrect rounding for negative values.\n"
681-
"To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), "
682-
"or for actual floor division, use torch.div(a, b, rounding_mode='floor')."
683-
);
684-
// FIXME: Not actually doing floor division (#43874)
685677
auto iter = TensorIterator::binary_op(result, self, other);
686-
div_trunc_stub(iter.device_type(), iter);
678+
div_floor_stub(iter.device_type(), iter);
687679
if (!result.defined()) {
688680
result = iter.output();
689681
}
690682
return result;
691683
}
692684

693685
Tensor floor_divide(const Tensor& self, const Tensor& other) {
694-
TORCH_WARN_ONCE(
695-
"floor_divide is deprecated, and will be removed in a future version of pytorch. "
696-
"It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). "
697-
"This results in incorrect rounding for negative values.\n"
698-
"To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), "
699-
"or for actual floor division, use torch.div(a, b, rounding_mode='floor')."
700-
);
701-
// FIXME: Not actually doing floor division (#43874)
702686
Tensor result;
703687
auto iter = TensorIterator::binary_op(result, self, other);
704-
div_trunc_stub(iter.device_type(), iter);
688+
div_floor_stub(iter.device_type(), iter);
705689
return iter.output();
706690
}
707691

‎test/jit/test_upgraders.py

Lines changed: 0 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -123,35 +123,6 @@ def test_aten_div_tensor_at_3(self):
123123
# can be different every time
124124
self.assertEqual(loaded_model.code, loaded_model_twice.code)
125125

126-
@unittest.skipIf(not _is_upgraders_enabled(), "Skipping because upgraders are not enabled")
127-
def test_aten_div_other_variants(self):
128-
def test_func():
129-
a = torch.ones((4, 5, 6), dtype=torch.int64)
130-
b = 4
131-
return a // b
132-
133-
traced_func = torch.jit.trace(test_func, ())
134-
buffer = io.BytesIO()
135-
torch.jit.save(traced_func, buffer)
136-
137-
current_flag_value = torch._C._get_version_calculator_flag()
138-
# calculate based on old version
139-
torch._C._calculate_package_version_based_on_upgraders(False)
140-
buffer.seek(0)
141-
loaded_func = torch.jit.load(buffer)
142-
version = self._load_model_version(loaded_func)
143-
self.assertTrue(version == 4)
144-
145-
# calculate based on new version
146-
torch._C._calculate_package_version_based_on_upgraders(True)
147-
buffer.seek(0)
148-
loaded_func = torch.jit.load(buffer)
149-
version = self._load_model_version(loaded_func)
150-
self.assertTrue(version == 4)
151-
152-
# make sure we preserve old behaviou
153-
torch._C._calculate_package_version_based_on_upgraders(current_flag_value)
154-
155126
@unittest.skipIf(not _is_upgraders_enabled(), "Skipping because upgraders are not enabled")
156127
def test_aten_full_other_variants(self):
157128
def test_func():

‎test/onnx/test_pytorch_onnx_onnxruntime.py

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1995,6 +1995,7 @@ def forward(self, x):
19951995
x = torch.randn(2, 3)
19961996
self.run_test(ArithmeticModule(), x)
19971997

1998+
@unittest.skip("Floor division on ONNX is inconsistent with eager (see #78411)")
19981999
def test_floor_div(self):
19992000
class FloorDivModule(torch.nn.Module):
20002001
def forward(self, x, y):
@@ -2017,6 +2018,7 @@ def forward(self, x, y):
20172018
y = torch.arange(1, 2 * 3 * 4 + 1).reshape(2, 3, 4)
20182019
self.run_test(FloorDivModule(), (x, y))
20192020

2021+
@unittest.skip("Floor division on ONNX is inconsistent with eager (see #78411)")
20202022
def test_floor_div_script(self):
20212023
class FloorDivModule(torch.jit.ScriptModule):
20222024
@torch.jit.script_method
@@ -2027,6 +2029,7 @@ def forward(self, x, y):
20272029
y = torch.randn(2, 3, 4)
20282030
self.run_test(FloorDivModule(), (x, y))
20292031

2032+
@unittest.skip("Floor division on ONNX is inconsistent with eager (see #78411)")
20302033
@skipIfUnsupportedMinOpsetVersion(9)
20312034
def test_floordiv(self):
20322035
class FloordivModule(torch.nn.Module):

‎test/test_binary_ufuncs.py

Lines changed: 27 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -164,7 +164,7 @@ def _numel(x):
164164
# Assumes x is a scalar
165165
return 1
166166

167-
if _numel(l) < 10 and _numel(r) < 10:
167+
if _numel(l) <= 100 and _numel(r) <= 100:
168168
msg = (
169169
"Failed to produce expected results! Input lhs tensor was"
170170
" {0}, rhs tensor was {1}, torch result is {2}, and reference result is"
@@ -1261,8 +1261,7 @@ def test_inplace_dunders(self, device):
12611261
t *= 1
12621262
t /= 1
12631263
t **= 1
1264-
with self.assertWarnsOnceRegex(UserWarning, "floor_divide"):
1265-
t //= 1
1264+
t //= 1
12661265
t %= 1
12671266
self.assertEqual(expected, t.data_ptr())
12681267

@@ -1902,8 +1901,6 @@ def test_binary_op_scalar_device_unspecified(self, devices):
19021901
def test_div_and_floordiv_vs_python(self, device):
19031902
# Tests torch division ops which can handle both arguments being
19041903
# scalars.
1905-
# NOTE: torch.floor_divide currently truncates instead of flooring.
1906-
# the quotient. See https://github.com/pytorch/pytorch/issues/43874.
19071904
def _scalar_helper(python_op, torch_op):
19081905
for a, b in product(range(-10, 10), range(-10, 10)):
19091906
for op in (lambda x: x * 0.5, lambda x: math.floor(x)):
@@ -1926,19 +1923,16 @@ def _scalar_helper(python_op, torch_op):
19261923
actual_first_tensor = torch_op(a_t, b)
19271924
actual_second_tensor = torch_op(a, b_t)
19281925

1929-
self.assertEqual(actual_scalar, expected_div)
1930-
self.assertEqual(actual_tensor.item(), expected_div)
1926+
self.assertEqual(actual_scalar, expected)
1927+
self.assertEqual(actual_tensor.item(), expected)
19311928
self.assertEqual(actual_first_tensor, actual_tensor)
19321929
self.assertEqual(actual_second_tensor, actual_tensor)
19331930

19341931
_scalar_helper(operator.truediv, operator.truediv)
19351932
_scalar_helper(operator.truediv, torch.true_divide)
1936-
with self.assertWarnsOnceRegex(UserWarning, "floor_divide"):
1937-
_scalar_helper(lambda a, b: math.trunc(a / b), operator.floordiv)
1938-
_scalar_helper(lambda a, b: math.trunc(a / b), torch.floor_divide)
1933+
_scalar_helper(lambda a, b: math.floor(a / b), operator.floordiv)
1934+
_scalar_helper(lambda a, b: math.floor(a / b), torch.floor_divide)
19391935

1940-
# NOTE: torch.floor_divide currently truncates instead of flooring.
1941-
# See https://github.com/pytorch/pytorch/issues/43874.
19421936
@onlyNativeDeviceTypes
19431937
def test_div_and_floordiv_script_vs_python(self, device):
19441938
# Creates jitted functions of two tensors
@@ -1960,13 +1954,12 @@ def _wrapped_floordiv(a, b):
19601954
continue
19611955

19621956
expected_div = a / b
1963-
expected_truncdiv = math.trunc(a / b)
1957+
expected_floordiv = math.floor(a / b)
19641958
a_t = torch.tensor(a, device=device)
19651959
b_t = torch.tensor(b, device=device)
19661960

19671961
self.assertEqual(scripted_div(a_t, b_t), expected_div)
1968-
with self.assertWarnsOnceRegex(UserWarning, "floor_divide"):
1969-
self.assertEqual(scripted_floordiv(a_t, b_t), expected_truncdiv)
1962+
self.assertEqual(scripted_floordiv(a_t, b_t), expected_floordiv)
19701963

19711964
# Creates jitted functions of one tensor
19721965
def _wrapped_div_scalar(a):
@@ -1996,8 +1989,6 @@ def _wrapped_rfloordiv_scalar(a):
19961989
a_t = torch.tensor(a, device=device)
19971990

19981991
self.assertEqual(a / 5, scripted_div_scalar(a_t))
1999-
with self.assertWarnsOnceRegex(UserWarning, "floor_divide"):
2000-
self.assertEqual(math.trunc(a / 5), scripted_floordiv_scalar(a_t))
20011992

20021993
# Skips zero divisors
20031994
if a == 0:
@@ -2014,8 +2005,6 @@ def _wrapped_rfloordiv_scalar(a):
20142005
# See issue gh-52387
20152006
self.assertEqual(5 // a, scripted_rfloordiv_scalar(a_t))
20162007

2017-
# NOTE: torch.floor_divide currently truncates instead of flooring
2018-
# the quotient. See https://github.com/pytorch/pytorch/issues/43874.
20192008
@onlyNativeDeviceTypes
20202009
def test_idiv_and_ifloordiv_vs_python(self, device):
20212010
def _wrapped_idiv_tensor(a, b):
@@ -2075,7 +2064,6 @@ def _wrapped_ifloordiv_scalar(a):
20752064

20762065
expected_idiv = a / b
20772066
expected_ifloordiv = a // b
2078-
expected_itruncdiv = math.trunc(a / b)
20792067

20802068
a_t = torch.tensor(a, device=device)
20812069
b_t = torch.tensor(b, device=device)
@@ -2110,39 +2098,27 @@ def _wrapped_ifloordiv_scalar(a):
21102098
if not a_t.is_floating_point() and b_t.is_floating_point():
21112099
# Inplace modification fails because a float tensor is required
21122100
# if the divisor is a float tensor
2113-
with self.assertRaises(RuntimeError), self.assertWarnsOnceRegex(
2114-
UserWarning, "floor_divide"
2115-
):
2116-
a_t.clone().floor_divide_(b_t)
2117-
with self.assertRaises(RuntimeError), self.assertWarnsOnceRegex(
2118-
UserWarning, "floor_divide"
2119-
):
2120-
scripted_floor_divide_tensor(a_t.clone(), b_t)
2101+
a_t.clone().floor_divide_(b_t)
2102+
scripted_floor_divide__tensor(a_t.clone(), b_t)
21212103
tmp = a_t.clone()
2122-
with self.assertRaises(RuntimeError), self.assertWarnsOnceRegex(
2123-
UserWarning, "floor_divide"
2124-
):
2125-
tmp //= b_t
2104+
tmp //= b_t
21262105
else:
21272106
# Inplace modification is OK when both or neither tensor is
21282107
# a float tensor
2129-
with self.assertWarnsOnceRegex(UserWarning, "floor_divide"):
2130-
self.assertEqual(
2131-
a_t.clone().floor_divide_(b_t).item(), expected_itruncdiv
2132-
)
2133-
self.assertEqual(
2134-
scripted_floor_divide__tensor(a_t.clone(), b_t).item(),
2135-
expected_itruncdiv,
2136-
)
2137-
tmp = a_t.clone()
2138-
with self.assertWarnsOnceRegex(UserWarning, "floor_divide"):
2139-
tmp //= b_t
2140-
self.assertEqual(tmp.item(), expected_itruncdiv)
2141-
2142-
with self.assertWarnsOnceRegex(UserWarning, "floor_divide"):
21432108
self.assertEqual(
2144-
scripted_floor_divide__scalar(a_t), math.trunc(a / 5)
2109+
a_t.clone().floor_divide_(b_t).item(), expected_ifloordiv
2110+
)
2111+
self.assertEqual(
2112+
scripted_floor_divide__tensor(a_t.clone(), b_t).item(),
2113+
expected_ifloordiv,
21452114
)
2115+
tmp = a_t.clone()
2116+
tmp //= b_t
2117+
self.assertEqual(tmp.item(), expected_ifloordiv)
2118+
2119+
self.assertEqual(
2120+
scripted_floor_divide__scalar(a_t), math.floor(a / 5)
2121+
)
21462122

21472123
# Tests binary op equivalence with Python builtin ops
21482124
# Also tests that reverse operations are equivalent to forward ops
@@ -2747,9 +2723,8 @@ def test_floor_divide_tensor(self, device, dtype):
27472723
x = torch.randn(10, device=device).mul(30).to(dtype)
27482724
y = torch.arange(1, 11, dtype=dtype, device=device)
27492725

2750-
with self.assertWarnsOnceRegex(UserWarning, "__floordiv__"):
2751-
z = x // y
2752-
z_alt = torch.trunc(x.double() / y.double()).to(dtype)
2726+
z = x // y
2727+
z_alt = torch.floor(x.double() / y.double()).to(dtype)
27532728

27542729
self.assertEqual(z.dtype, x.dtype)
27552730
self.assertEqual(z, z_alt)
@@ -2761,36 +2736,14 @@ def test_floor_divide_tensor(self, device, dtype):
27612736
def test_floor_divide_scalar(self, device, dtype):
27622737
x = torch.randn(100, device=device).mul(10).to(dtype)
27632738

2764-
with self.assertWarnsOnceRegex(UserWarning, "__floordiv__"):
2765-
z = x // 3
2739+
z = x // 3
27662740
z_alt = torch.tensor(
2767-
[math.trunc(v.item() / 3.0) for v in x], dtype=x.dtype, device=device
2741+
[math.floor(v.item() / 3.0) for v in x], dtype=x.dtype, device=device
27682742
)
27692743

27702744
self.assertEqual(z.dtype, x.dtype)
27712745
self.assertEqual(z, z_alt)
27722746

2773-
# Note: this tests fails on XLA
2774-
@onlyNativeDeviceTypes
2775-
@dtypes(torch.float, torch.long)
2776-
def test_floor_divide_out(self, device, dtype):
2777-
x = torch.randn(10, device=device).mul(10).to(dtype)
2778-
y = torch.arange(1, 11, dtype=dtype, device=device)
2779-
o = torch.empty(10, dtype=dtype, device=device)
2780-
2781-
with self.assertWarnsOnceRegex(UserWarning, "floor_divide"):
2782-
torch.floor_divide(x, y, out=o)
2783-
self.assertEqual(o, x // y)
2784-
2785-
# Tests scalar with out
2786-
torch.floor_divide(x, 2, out=o)
2787-
self.assertEqual(o, x // 2)
2788-
2789-
if dtype == torch.int:
2790-
o = torch.empty(10, dtype=torch.float, device=device)
2791-
torch.floor_divide(x, y, out=o)
2792-
self.assertEqual(o, torch.floor_divide(x.float(), y.float()))
2793-
27942747
@onlyCPU
27952748
@dtypes(*get_all_math_dtypes("cpu"))
27962749
def test_rdiv(self, device, dtype):

‎test/test_jit.py

Lines changed: 11 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -7090,19 +7090,6 @@ def test_number_div(self):
70907090
self.checkScript(div_int_nofuture, ())
70917091
self.checkScript(div_float_nofuture, ())
70927092

7093-
def test_floor_div(self):
7094-
@torch.jit.script
7095-
def foo(a, b):
7096-
# type: (int, int) -> int
7097-
return a // b
7098-
for i in range(-8, 8):
7099-
for j in range(-8, 8):
7100-
if j != 0:
7101-
self.assertEqual(foo(i, j), i // j)
7102-
else:
7103-
with self.assertRaisesRegex(RuntimeError, 'division by 0'):
7104-
foo(i, j)
7105-
71067093
# Testing bitwise shorthand aug assignment
71077094
def test_bool_augassign_bitwise_or(self):
71087095
def func(a: bool, b: bool) -> bool:
@@ -12514,6 +12501,16 @@ def fn():
1251412501
for a, b in zip(eager_out, script_out):
1251512502
check_equal_and_dtype(a, b)
1251612503

12504+
def test_floor_div(self):
12505+
@torch.jit.script
12506+
def foo(a, b):
12507+
# type: (int, int) -> int
12508+
return a // b
12509+
for i in range(-8, 8):
12510+
for j in range(-8, 8):
12511+
if j != 0:
12512+
self.assertEqual(foo(i, j), i // j)
12513+
1251712514
def test_floordiv(self):
1251812515
funcs_template = dedent('''
1251912516
def fn():
@@ -12532,8 +12529,7 @@ def fn():
1253212529
cu = torch.jit.CompilationUnit(funcs_str)
1253312530
f_script = cu.fn
1253412531
f = scope['fn']
12535-
with self.assertWarnsOnceRegex(UserWarning, "floor_divide"):
12536-
self.assertEqual(f_script(), f())
12532+
self.assertEqual(f_script(), f())
1253712533

1253812534
def test_call_python_fn_from_script_fn(self):
1253912535
@torch.jit.ignore

‎test/test_sparse.py

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1663,11 +1663,9 @@ def _test_basic_ops_shape(self, nnz_x1, nnz_x2, shape_i, shape_v, dtype, device,
16631663
self.assertEqual(self.safeToDense(y1), expected)
16641664
self.assertEqual(self.safeToDense(y2), expected)
16651665

1666-
with self.assertWarnsOnceRegex(UserWarning, '__floordiv__'):
1667-
y1 = x1 // 37.5
1666+
y1 = x1 // 37.5
16681667
y2 = x1.clone()
1669-
with self.assertWarnsOnceRegex(UserWarning, 'floor_divide'):
1670-
y2.floor_divide_(37.5)
1668+
y2.floor_divide_(37.5)
16711669
expected = self.safeToDense(x1) // 37.5
16721670
self.assertEqual(self.safeToDense(y1), expected)
16731671
self.assertEqual(self.safeToDense(y2), expected)
@@ -3010,7 +3008,7 @@ def test_div_by_sparse_error(self, device):
30103008
/ torch.tensor(1., device=device).to_sparse())
30113009

30123010
def test_floor_divide_by_sparse_error(self, device):
3013-
self.assertRaisesRegex(RuntimeError, 'Sparse division requires',
3011+
self.assertRaisesRegex(RuntimeError, 'Sparse floor division requires',
30143012
lambda: torch.tensor(1., device=device).to_sparse()
30153013
// torch.tensor(1., device=device).to_sparse())
30163014

‎torch/_tensor.py

Lines changed: 2 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -666,21 +666,11 @@ def __rpow__(self, other):
666666

667667
@_handle_torch_function_and_wrap_type_error_to_not_implemented
668668
def __floordiv__(self, other):
669-
warnings.warn("__floordiv__ is deprecated, and its behavior will change in a future version of pytorch. "
670-
"It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). "
671-
"This results in incorrect rounding for negative values. "
672-
"To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), "
673-
"or for actual floor division, use torch.div(a, b, rounding_mode='floor').", stacklevel=3)
674-
return torch.div(self, other, rounding_mode='trunc')
669+
return torch.floor_divide(self, other)
675670

676671
@_handle_torch_function_and_wrap_type_error_to_not_implemented
677672
def __rfloordiv__(self, other):
678-
warnings.warn("__rfloordiv__ is deprecated, and its behavior will change in a future version of pytorch. "
679-
"It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). "
680-
"This results in incorrect rounding for negative values. "
681-
"To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), "
682-
"or for actual floor division, use torch.div(a, b, rounding_mode='floor').", stacklevel=3)
683-
return torch.div(other, self, rounding_mode='trunc')
673+
return torch.floor_divide(other, self)
684674

685675
@_handle_torch_function_and_wrap_type_error_to_not_implemented
686676
def __rlshift__(self, other):

0 commit comments

Comments
 (0)
0