[BE]: Apply FURB118 (prev): replaces unnecessary lambdas with operator. (#116027) This replaces a bunch of unnecessary lambdas with the operator package. This is semantically equivalent, but the operator package is faster, and arguably more readable. When the FURB rules are taken out of preview, I will enable it as a ruff check. Pull Request resolved: https://github.com/pytorch/pytorch/pull/116027 Approved by: https://github.com/malfet
diff --git a/test/nn/test_pooling.py b/test/nn/test_pooling.py index 2c14b03..21e9125 100644 --- a/test/nn/test_pooling.py +++ b/test/nn/test_pooling.py
@@ -25,6 +25,7 @@ import torch.nn.functional as F import torch.nn as nn from torch.autograd import gradcheck, gradgradcheck +import operator class TestAvgPool(TestCase): @@ -42,11 +43,11 @@ return joined_x.view(1, joined_x.numel()) def _avg_pool2d(self, x, kernel_size): - size = reduce((lambda x, y: x * y), kernel_size) + size = reduce(operator.mul, kernel_size) return self._sum_pool2d(x, kernel_size) / size def _avg_pool3d(self, x, kernel_size): - size = reduce((lambda x, y: x * y), kernel_size) + size = reduce(operator.mul, kernel_size) return self._sum_pool3d(x, kernel_size) / size def test_doubletensor_avg_pool2d(self):
diff --git a/test/onnx/test_operators.py b/test/onnx/test_operators.py index a12b9f3..ed72229 100644 --- a/test/onnx/test_operators.py +++ b/test/onnx/test_operators.py
@@ -10,6 +10,7 @@ import inspect import io import itertools +import operator import os import shutil import tempfile @@ -172,27 +173,27 @@ def test_add_broadcast(self): x = torch.randn(2, 3, requires_grad=True).double() y = torch.randn(3, requires_grad=True).double() - self.assertONNX(lambda x, y: x + y, (x, y)) + self.assertONNX(operator.add, (x, y)) def test_add_left_broadcast(self): x = torch.randn(3, requires_grad=True).double() y = torch.randn(2, 3, requires_grad=True).double() - self.assertONNX(lambda x, y: x + y, (x, y)) + self.assertONNX(operator.add, (x, y)) def test_add_size1_broadcast(self): x = torch.randn(2, 3, requires_grad=True).double() y = torch.randn(2, 1, requires_grad=True).double() - self.assertONNX(lambda x, y: x + y, (x, y)) + self.assertONNX(operator.add, (x, y)) def test_add_size1_right_broadcast(self): x = torch.randn(2, 3, requires_grad=True).double() y = torch.randn(3, requires_grad=True).double() - self.assertONNX(lambda x, y: x + y, (x, y)) + self.assertONNX(operator.add, (x, y)) def test_add_size1_singleton_broadcast(self): x = torch.randn(2, 3, requires_grad=True).double() y = torch.randn(1, 3, requires_grad=True).double() - self.assertONNX(lambda x, y: x + y, (x, y)) + self.assertONNX(operator.add, (x, y)) def test_rsub(self): x = torch.randn(2, 3, requires_grad=True).double() @@ -541,27 +542,27 @@ def test_equal(self): x = torch.randn(1, 2, 3, 1, requires_grad=False).int() y = torch.randn(1, 4, requires_grad=False).int() - self.assertONNX(lambda x, y: x == y, (x, y)) + self.assertONNX(operator.eq, (x, y)) def test_lt(self): x = torch.randn(1, 2, 3, 1, requires_grad=False).int() y = torch.randn(1, 4, requires_grad=False).int() - self.assertONNX(lambda x, y: x < y, (x, y)) + self.assertONNX(operator.lt, (x, y)) def test_gt(self): x = torch.randn(1, 2, 3, 1, requires_grad=False).int() y = torch.randn(1, 4, requires_grad=False).int() - self.assertONNX(lambda x, y: x > y, (x, y)) + self.assertONNX(operator.gt, (x, y)) def test_le(self): x = torch.randn(3, 4, requires_grad=False).int() y = torch.randn(3, 4, requires_grad=False).int() - self.assertONNX(lambda x, y: x <= y, (x, y)) + self.assertONNX(operator.le, (x, y)) def test_ge(self): x = torch.randn(3, 4, requires_grad=False).int() y = torch.randn(3, 4, requires_grad=False).int() - self.assertONNX(lambda x, y: x >= y, (x, y)) + self.assertONNX(operator.ge, (x, y)) def test_exp(self): x = torch.randn(3, 4, requires_grad=True) @@ -862,7 +863,7 @@ def test_master_opset(self): x = torch.randn(2, 3).float() y = torch.randn(2, 3).float() - self.assertONNX(lambda x, y: x + y, (x, y), opset_version=10) + self.assertONNX(operator.add, (x, y), opset_version=10) def test_std(self): x = torch.randn(2, 3, 4).float()
diff --git a/test/test_binary_ufuncs.py b/test/test_binary_ufuncs.py index 9fcc8b4..d5fcd55 100644 --- a/test/test_binary_ufuncs.py +++ b/test/test_binary_ufuncs.py
@@ -2980,17 +2980,17 @@ @onlyCPU @dtypes(torch.float) def test_cdiv(self, device, dtype): - self._test_cop(torch.div, lambda x, y: x / y, dtype, device) + self._test_cop(torch.div, operator.truediv, dtype, device) @onlyCPU @dtypes(torch.float) def test_cremainder(self, device, dtype): - self._test_cop(torch.remainder, lambda x, y: x % y, dtype, device) + self._test_cop(torch.remainder, operator.mod, dtype, device) @onlyCPU @dtypes(torch.float) def test_cmul(self, device, dtype): - self._test_cop(torch.mul, lambda x, y: x * y, dtype, device) + self._test_cop(torch.mul, operator.mul, dtype, device) @onlyCPU @dtypes(torch.float)
diff --git a/test/test_datapipe.py b/test/test_datapipe.py index 61f086b..469994e 100644 --- a/test/test_datapipe.py +++ b/test/test_datapipe.py
@@ -63,6 +63,7 @@ from torch.utils.data.datapipes.dataframe import CaptureDataFrame from torch.utils.data.datapipes.dataframe import dataframe_wrapper as df_wrapper from torch.utils.data.datapipes.iter.sharding import SHARDING_PRIORITIES +import operator try: import dill @@ -1361,8 +1362,8 @@ # Unmatched input columns with fn arguments _helper(None, fn_n1, 1, error=ValueError) _helper(None, fn_n1, [0, 1, 2], error=ValueError) - _helper(None, lambda d0, d1: d0 + d1, 0, error=ValueError) - _helper(None, lambda d0, d1: d0 + d1, [0, 1, 2], error=ValueError) + _helper(None, operator.add, 0, error=ValueError) + _helper(None, operator.add, [0, 1, 2], error=ValueError) _helper(None, fn_cmplx, 0, 1, ValueError) _helper(None, fn_n1_pos, 1, error=ValueError) _helper(None, fn_n1_def, [0, 1, 2], 1, error=ValueError)
diff --git a/test/test_indexing.py b/test/test_indexing.py index cfaedd5..e5e854d 100644 --- a/test/test_indexing.py +++ b/test/test_indexing.py
@@ -16,6 +16,7 @@ from torch.testing._internal.common_device_type import ( instantiate_device_type_tests, onlyCUDA, dtypes, dtypesIfCPU, dtypesIfCUDA, onlyNativeDeviceTypes, skipXLA) +import operator class TestIndexing(TestCase): @@ -138,7 +139,7 @@ def consec(size, start=1): # Creates the sequence in float since CPU half doesn't support the # needed operations. Converts to dtype before returning. - numel = reduce(lambda x, y: x * y, size, 1) + numel = reduce(operator.mul, size, 1) sequence = torch.ones(numel, dtype=torch.float, device=device).cumsum(0) sequence.add_(start - 1) return sequence.view(*size).to(dtype=dtype)
diff --git a/test/test_linalg.py b/test/test_linalg.py index 3f00da5..8d60d66 100644 --- a/test/test_linalg.py +++ b/test/test_linalg.py
@@ -33,6 +33,7 @@ _get_torch_cuda_version from torch.distributions.binomial import Binomial import torch.backends.opt_einsum as opt_einsum +import operator # Protects against includes accidentally setting the default dtype assert torch.get_default_dtype() is torch.float32 @@ -7008,7 +7009,7 @@ # mat_chars denotes matrix characteristics # possible values are: sym, sym_psd, sym_pd, sing, non_sym def run_test(matsize, batchdims, mat_chars): - num_matrices = reduce(lambda x, y: x * y, batchdims, 1) + num_matrices = reduce(operator.mul, batchdims, 1) list_of_matrices = [] for idx in range(num_matrices):
diff --git a/test/test_mps.py b/test/test_mps.py index ae43dd5..cf628a7 100644 --- a/test/test_mps.py +++ b/test/test_mps.py
@@ -44,6 +44,7 @@ import torch import torch.utils._pytree as pytree from itertools import product +import operator test_consistency_op_db = copy.deepcopy(op_db) test_error_inputs_op_db = copy.deepcopy(op_db) @@ -1388,11 +1389,11 @@ return joined_x.view(1, joined_x.numel()) def _avg_pool2d(self, x, kernel_size): - size = reduce((lambda x, y: x * y), kernel_size) + size = reduce(operator.mul, kernel_size) return self._sum_pool2d(x, kernel_size) / size def _avg_pool3d(self, x, kernel_size): - size = reduce((lambda x, y: x * y), kernel_size) + size = reduce(operator.mul, kernel_size) return self._sum_pool3d(x, kernel_size) / size def test_avg_pool2d_with_zero_divisor(self):
diff --git a/test/test_sparse_csr.py b/test/test_sparse_csr.py index 12061aa..b83933d 100644 --- a/test/test_sparse_csr.py +++ b/test/test_sparse_csr.py
@@ -22,6 +22,7 @@ all_types_and_complex, floating_and_complex_types_and) from torch.testing._internal.opinfo.definitions.sparse import validate_sample_input_sparse from test_sparse import CUSPARSE_SPMM_COMPLEX128_SUPPORTED +import operator if TEST_SCIPY: import scipy.sparse as sp @@ -3310,7 +3311,7 @@ # random bool vector w/ length equal to max possible nnz for the sparse_shape mask_source = make_tensor(batch_mask_shape, dtype=torch.bool, device=device).flatten() - n_batch = functools.reduce(lambda x, y: x * y, batch_shape, 1) + n_batch = functools.reduce(operator.mul, batch_shape, 1) # stack random permutations of the source for each batch mask = torch.stack([mask_source[torch.randperm(mask_source.numel())]
diff --git a/test/test_testing.py b/test/test_testing.py index 542601d..12ef27c 100644 --- a/test/test_testing.py +++ b/test/test_testing.py
@@ -29,6 +29,7 @@ from torch.testing._internal.common_dtype import all_types_and_complex_and, floating_types from torch.testing._internal.common_modules import modules, module_db, ModuleInfo from torch.testing._internal.opinfo.core import SampleInput, DecorateInfo, OpInfo +import operator # For testing TestCase methods and torch.testing functions class TestTesting(TestCase): @@ -1427,7 +1428,7 @@ @parametrize("noncontiguous", [False, True]) @parametrize("shape", [tuple(), (0,), (1,), (1, 1), (2,), (2, 3), (8, 16, 32)]) def test_noncontiguous(self, dtype, device, noncontiguous, shape): - numel = functools.reduce(lambda a, b: a * b, shape, 1) + numel = functools.reduce(operator.mul, shape, 1) t = torch.testing.make_tensor(shape, dtype=dtype, device=device, noncontiguous=noncontiguous) self.assertEqual(t.is_contiguous(), not noncontiguous or numel < 2)
diff --git a/test/test_type_promotion.py b/test/test_type_promotion.py index db808c7..ceef13b 100644 --- a/test/test_type_promotion.py +++ b/test/test_type_promotion.py
@@ -18,6 +18,7 @@ import numpy as np +import operator # load_tests from torch.testing._internal.common_utils is used to automatically filter tests for # sharding on sandcastle. This line silences flake warnings @@ -550,37 +551,37 @@ name="lt", out_op=lambda x, y, d: torch.lt(x, y, out=torch.empty(0, dtype=torch.bool, device=d)), ret_op=lambda x, y: torch.lt(x, y), - compare_op=lambda x, y: x < y, + compare_op=operator.lt, ), dict( name="le", out_op=lambda x, y, d: torch.le(x, y, out=torch.empty(0, dtype=torch.bool, device=d)), ret_op=lambda x, y: torch.le(x, y), - compare_op=lambda x, y: x <= y, + compare_op=operator.le, ), dict( name="gt", out_op=lambda x, y, d: torch.gt(x, y, out=torch.empty(0, dtype=torch.bool, device=d)), ret_op=lambda x, y: torch.gt(x, y), - compare_op=lambda x, y: x > y, + compare_op=operator.gt, ), dict( name="ge", out_op=lambda x, y, d: torch.ge(x, y, out=torch.empty(0, dtype=torch.bool, device=d)), ret_op=lambda x, y: torch.ge(x, y), - compare_op=lambda x, y: x >= y, + compare_op=operator.ge, ), dict( name="eq", out_op=lambda x, y, d: torch.eq(x, y, out=torch.empty(0, dtype=torch.bool, device=d)), ret_op=lambda x, y: torch.eq(x, y), - compare_op=lambda x, y: x == y, + compare_op=operator.eq, ), dict( name="ne", out_op=lambda x, y, d: torch.ne(x, y, out=torch.empty(0, dtype=torch.bool, device=d)), ret_op=lambda x, y: torch.ne(x, y), - compare_op=lambda x, y: x != y, + compare_op=operator.ne, ), ] for op in comparison_ops: @@ -627,12 +628,12 @@ @onlyNativeDeviceTypes def test_complex_assertraises(self, device): comparison_ops = [ - dict(name="lt", compare_op=lambda x, y: x < y, ), - dict(name="le", compare_op=lambda x, y: x <= y, ), - dict(name="gt", compare_op=lambda x, y: x > y, ), - dict(name="ge", compare_op=lambda x, y: x >= y, ), - dict(name="eq", compare_op=lambda x, y: x == y, ), - dict(name="ne", compare_op=lambda x, y: x != y, ), + dict(name="lt", compare_op=operator.lt, ), + dict(name="le", compare_op=operator.le, ), + dict(name="gt", compare_op=operator.gt, ), + dict(name="ge", compare_op=operator.ge, ), + dict(name="eq", compare_op=operator.eq, ), + dict(name="ne", compare_op=operator.ne, ), ] for op in comparison_ops: is_cuda = torch.device(device).type == 'cuda'
diff --git a/test/torch_np/numpy_tests/core/test_numeric.py b/test/torch_np/numpy_tests/core/test_numeric.py index 7d9343b..131ef7b 100644 --- a/test/torch_np/numpy_tests/core/test_numeric.py +++ b/test/torch_np/numpy_tests/core/test_numeric.py
@@ -15,6 +15,7 @@ IS_WASM = False HAS_REFCOUNT = True +import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st @@ -701,25 +702,19 @@ # The value of tiny for double double is NaN, so we need to # pass the assert if not np.isnan(ft_tiny): - self.assert_raises_fpe(underflow, lambda a, b: a / b, ft_tiny, ft_max) - self.assert_raises_fpe(underflow, lambda a, b: a * b, ft_tiny, ft_tiny) - self.assert_raises_fpe(overflow, lambda a, b: a * b, ft_max, ftype(2)) - self.assert_raises_fpe(overflow, lambda a, b: a / b, ft_max, ftype(0.5)) - self.assert_raises_fpe(overflow, lambda a, b: a + b, ft_max, ft_max * ft_eps) - self.assert_raises_fpe(overflow, lambda a, b: a - b, -ft_max, ft_max * ft_eps) + self.assert_raises_fpe(underflow, operator.truediv, ft_tiny, ft_max) + self.assert_raises_fpe(underflow, operator.mul, ft_tiny, ft_tiny) + self.assert_raises_fpe(overflow, operator.mul, ft_max, ftype(2)) + self.assert_raises_fpe(overflow, operator.truediv, ft_max, ftype(0.5)) + self.assert_raises_fpe(overflow, operator.add, ft_max, ft_max * ft_eps) + self.assert_raises_fpe(overflow, operator.sub, -ft_max, ft_max * ft_eps) self.assert_raises_fpe(overflow, np.power, ftype(2), ftype(2**fi.nexp)) - self.assert_raises_fpe(divbyzero, lambda a, b: a / b, ftype(1), ftype(0)) - self.assert_raises_fpe( - invalid, lambda a, b: a / b, ftype(np.inf), ftype(np.inf) - ) - self.assert_raises_fpe(invalid, lambda a, b: a / b, ftype(0), ftype(0)) - self.assert_raises_fpe( - invalid, lambda a, b: a - b, ftype(np.inf), ftype(np.inf) - ) - self.assert_raises_fpe( - invalid, lambda a, b: a + b, ftype(np.inf), ftype(-np.inf) - ) - self.assert_raises_fpe(invalid, lambda a, b: a * b, ftype(0), ftype(np.inf)) + self.assert_raises_fpe(divbyzero, operator.truediv, ftype(1), ftype(0)) + self.assert_raises_fpe(invalid, operator.truediv, ftype(np.inf), ftype(np.inf)) + self.assert_raises_fpe(invalid, operator.truediv, ftype(0), ftype(0)) + self.assert_raises_fpe(invalid, operator.sub, ftype(np.inf), ftype(np.inf)) + self.assert_raises_fpe(invalid, operator.add, ftype(np.inf), ftype(-np.inf)) + self.assert_raises_fpe(invalid, operator.mul, ftype(0), ftype(np.inf)) @skipif(IS_WASM, reason="no wasm fp exception support") def test_warnings(self):