The GitHub Actions job "Lint" on tvm.git/fix/relax-torch-scalar-promotion has failed. Run started by GitHub user hiyufan (triggered by hiyufan).
Head commit for run: 0b01144d2c5c909b57b99ed8a7c84a7445c1fabe / Chen Yufan <[email protected]> [Fix][Relax][Frontend][Torch] Promote the tensor, not the scalar, in binary ops with a Python scalar `_binary_op` built the constant for a Python scalar operand in the tensor's own dtype, so a float scalar against an integer or bool tensor was truncated before the op ran: `x * 0.5` on an int64 tensor became `x * 0`, `x + 0.5` became `x + 0`, `x < 1.5` became `x < 1`, and `bool_tensor * 2.5` stayed bool. torch promotes the other way. A Python scalar takes part in type promotion at a lower priority than a tensor and widens it only when its category is higher: a float scalar promotes an integer or bool tensor to the default float dtype, an int scalar promotes a bool tensor to int64, and otherwise the tensor's dtype wins. Use torch.result_type as the oracle for that rule, cast the tensor when it has to widen, and build the constant in the promoted dtype. Tensor-tensor promotion was already right and is untouched. The two Constant-vs-scalar dispatch branches pre-cast the scalar the same wrong way and now go through the same path. int64 tensor * 0.5 torch float32 [0.5, 1.0, 1.5] before int64 [0, 0, 0] int64 tensor + 0.5 torch float32 [1.5, 2.5, 3.5] before int64 [1, 2, 3] int64 tensor < 1.5 torch [T, F, F] before [F, F, F] bool tensor * 2.5 torch float32 [2.5, 0, 2.5] before bool [T, F, T] bool tensor + 1 torch int64 [2, 1, 2] before InternalError int64 tensor ** 0.5 torch float32 before InternalError Swept 18 binary ops x 8 tensor dtypes x 6 Python scalars (864 programs, 829 that torch accepts), each built with relax.build(llvm) and compared with torch on result dtype and values: before 477 matched 149 wrong dtype or values 203 raised after 645 matched 52 wrong 132 raised no case fails after this change that did not fail before it; 168 repaired Of what is left, 157 are the division family, where true division of two integers has to give a float even for an int scalar and div.Tensor_mode builds its constant with no dtype at all; that is a separate change. The rest are relax rejecting arithmetic on bool tensors, a uint8 tensor against a negative scalar (torch wraps, relax.const raises), and `x ** True` on an integer tensor. test_linspace's expected IR encoded the truncation: torch's decomposition splits the range at `i < 4.5`, which the frontend emitted as `R.less(i, R.const(4, "int64"))`. It now promotes the index to float32 and compares against 4.5, and the expected module is updated to match. Tests: an IR-level check that `int64 + 0.5` emits astype plus a float32 constant, and numeric checks over add/mul/lt/ge/eq (both operand orders) and sub/rsub/pow/ remainder across int64, int32, uint8, float16, float32 and bool tensors with int, float and bool scalars, asserting both the result dtype and the values. 22 of the 44 fail against the previous head; the other 22 are cases where the tensor's dtype wins, and pin that nothing there moved. Report URL: https://github.com/apache/tvm/actions/runs/35197346437 With regards, GitHub Actions via GitBox --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
