Skip to content

Instantly share code, notes, and snippets.

@maggiemoss

maggiemoss/pyrefly_errors_5

Created October 6, 2025 16:41
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save maggiemoss/4b3bf2037014e116bc00706a16aef199 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save maggiemoss/4b3bf2037014e116bc00706a16aef199 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
pyrefly_errors_5
WARN `_register_pytree_node` is deprecated [deprecated]
--> torch/_export/utils.py:39:5
|
39 | _register_pytree_node,
| ---------------------
|
ERROR Argument `str | Unknown` is not assignable to parameter `padding_mode` with type `Literal['circular', 'reflect', 'replicate', 'zeros']` in function `torch.ao.nn.qat.modules.conv.Conv1d.__init__` [bad-argument-type]
--> torch/ao/nn/intrinsic/qat/modules/conv_fused.py:623:26
|
623 | padding_mode=padding_mode,
| ^^^^^^^^^^^^
|
ERROR Argument `str | Unknown` is not assignable to parameter `padding_mode` with type `Literal['circular', 'reflect', 'replicate', 'zeros']` in function `torch.ao.nn.qat.modules.conv.Conv2d.__init__` [bad-argument-type]
--> torch/ao/nn/intrinsic/qat/modules/conv_fused.py:823:26
|
823 | padding_mode=padding_mode,
| ^^^^^^^^^^^^
|
ERROR Argument `str | Unknown` is not assignable to parameter `padding_mode` with type `Literal['circular', 'reflect', 'replicate', 'zeros']` in function `torch.ao.nn.qat.modules.conv.Conv3d.__init__` [bad-argument-type]
--> torch/ao/nn/intrinsic/qat/modules/conv_fused.py:1024:26
|
1024 | padding_mode=padding_mode,
| ^^^^^^^^^^^^
|
ERROR Class member `LinearReLU._FLOAT_MODULE` overrides parent class `Linear` in an inconsistent manner [bad-override]
--> torch/ao/nn/intrinsic/qat/modules/linear_relu.py:39:5
|
39 | _FLOAT_MODULE = nni.LinearReLU
| ^^^^^^^^^^^^^
|
`LinearReLU._FLOAT_MODULE` has type `type[LinearReLU]`, which is not consistent with `type[Linear]` in `Linear._FLOAT_MODULE` (the type of read-write attributes cannot be changed)
ERROR Class member `LinearReLU._FLOAT_MODULE` overrides parent class `Linear` in an inconsistent manner [bad-override]
--> torch/ao/nn/intrinsic/quantized/dynamic/modules/linear_relu.py:33:5
|
33 | _FLOAT_MODULE = nni.LinearReLU
| ^^^^^^^^^^^^^
|
`LinearReLU._FLOAT_MODULE` has type `type[LinearReLU]`, which is not consistent with `tuple[type[Linear], type[NonDynamicallyQuantizableLinear]]` in `Linear._FLOAT_MODULE` (the type of read-write attributes cannot be changed)
ERROR Argument `str | Unknown` is not assignable to parameter `padding_mode` with type `Literal['circular', 'reflect', 'replicate', 'zeros']` in function `torch.ao.nn.quantized.modules.conv.Conv1d.__init__` [bad-argument-type]
--> torch/ao/nn/intrinsic/quantized/modules/conv_relu.py:57:26
|
57 | padding_mode=padding_mode,
| ^^^^^^^^^^^^
|
ERROR TODO: Expr::attr_infer_for_type attribute base undefined for type: type[Never] (trying to access _FLOAT_MODULE) [missing-attribute]
--> torch/ao/nn/qat/modules/conv.py:117:21
|
117 | fused = cls._FLOAT_MODULE(*modules)
| ^^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `_freeze` with type `bool` in function `torch.nn.modules.sparse.Embedding.__init__` [bad-argument-type]
--> torch/ao/nn/qat/modules/embedding_ops.py:53:13
|
53 | **factory_kwargs,
| ^^^^^^^^^^^^^^^^
|
ERROR `None` is not assignable to attribute `bias` with type `Parameter` [bad-assignment]
--> torch/ao/nn/quantizable/modules/activation.py:173:42
|
173 | observed.linear_Q.bias = None
| ^^^^
|
ERROR `None` is not assignable to attribute `bias` with type `Parameter` [bad-assignment]
--> torch/ao/nn/quantizable/modules/activation.py:174:42
|
174 | observed.linear_K.bias = None
| ^^^^
|
ERROR `None` is not assignable to attribute `bias` with type `Parameter` [bad-assignment]
--> torch/ao/nn/quantizable/modules/activation.py:175:42
|
175 | observed.linear_V.bias = None
| ^^^^
|
ERROR Argument `bool` is not assignable to parameter `iterable` with type `Iterable[object]` in function `all` [bad-argument-type]
--> torch/ao/nn/quantizable/modules/activation.py:237:28
|
237 | assert all(bQ == 0)
| ^^^^^^^
|
ERROR Argument `bool` is not assignable to parameter `iterable` with type `Iterable[object]` in function `all` [bad-argument-type]
--> torch/ao/nn/quantizable/modules/activation.py:244:28
|
244 | assert all(bK == 0)
| ^^^^^^^
|
ERROR Argument `bool` is not assignable to parameter `iterable` with type `Iterable[object]` in function `all` [bad-argument-type]
--> torch/ao/nn/quantizable/modules/activation.py:250:28
|
250 | assert all(bV == 0)
| ^^^^^^^
|
ERROR `None` is not assignable to attribute `bias` with type `Parameter` [bad-assignment]
--> torch/ao/nn/quantizable/modules/activation.py:257:38
|
257 | self.linear_Q.bias = None
| ^^^^
|
ERROR `None` is not assignable to attribute `bias` with type `Parameter` [bad-assignment]
--> torch/ao/nn/quantizable/modules/activation.py:258:38
|
258 | self.linear_K.bias = None
| ^^^^
|
ERROR `None` is not assignable to attribute `bias` with type `Parameter` [bad-assignment]
--> torch/ao/nn/quantizable/modules/activation.py:259:38
|
259 | self.linear_V.bias = None
| ^^^^
|
ERROR Object of class `NoneType` has no attribute `size` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:466:19
|
466 | src_len = k.size(1)
| ^^^^^^
|
ERROR Object of class `NoneType` has no attribute `size` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:474:36
|
474 | k_zeros = torch.zeros((k.size(0), 1) + k.size()[2:])
| ^^^^^^
|
ERROR Object of class `NoneType` has no attribute `size` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:474:52
|
474 | k_zeros = torch.zeros((k.size(0), 1) + k.size()[2:])
| ^^^^^^
|
ERROR Object of class `NoneType` has no attribute `is_quantized` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:475:16
|
475 | if k.is_quantized:
| ^^^^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `q_scale` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:477:30
|
477 | k_zeros, k.q_scale(), k.q_zero_point(), k.dtype
| ^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `q_zero_point` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:477:43
|
477 | k_zeros, k.q_scale(), k.q_zero_point(), k.dtype
| ^^^^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `dtype` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:477:61
|
477 | k_zeros, k.q_scale(), k.q_zero_point(), k.dtype
| ^^^^^^^
|
ERROR No matching overload found for function `torch._C._VariableFunctions.cat` [no-matching-overload]
--> torch/ao/nn/quantizable/modules/activation.py:479:26
|
479 | k = torch.cat([k, k_zeros], dim=1)
| ^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(tensors: list[Tensor] | tuple[Tensor, ...] | None, dim: int = 0, *, out: Tensor | None = None) -> Tensor [closest match]
(tensors: list[Tensor] | tuple[Tensor, ...] | None, dim: EllipsisType | str | None, *, out: Tensor | None = None) -> Tensor
ERROR Object of class `NoneType` has no attribute `size` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:480:36
|
480 | v_zeros = torch.zeros((v.size(0), 1) + k.size()[2:])
| ^^^^^^
|
ERROR Object of class `NoneType` has no attribute `is_quantized` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:481:16
|
481 | if v.is_quantized:
| ^^^^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `q_scale` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:483:30
|
483 | v_zeros, v.q_scale(), v.q_zero_point(), v.dtype
| ^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `q_zero_point` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:483:43
|
483 | v_zeros, v.q_scale(), v.q_zero_point(), v.dtype
| ^^^^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `dtype` [missing-attribute]
--> torch/ao/nn/quantizable/modules/activation.py:483:61
|
483 | v_zeros, v.q_scale(), v.q_zero_point(), v.dtype
| ^^^^^^^
|
ERROR No matching overload found for function `torch._C._VariableFunctions.cat` [no-matching-overload]
--> torch/ao/nn/quantizable/modules/activation.py:485:26
|
485 | v = torch.cat([v, v_zeros], dim=1)
| ^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(tensors: list[Tensor] | tuple[Tensor, ...] | None, dim: int = 0, *, out: Tensor | None = None) -> Tensor [closest match]
(tensors: list[Tensor] | tuple[Tensor, ...] | None, dim: EllipsisType | str | None, *, out: Tensor | None = None) -> Tensor
ERROR Argument `Any | None` is not assignable to parameter `value` with type `Module | Tensor` in function `torch.nn.modules.module.Module.__setattr__` [bad-argument-type]
--> torch/ao/nn/quantizable/modules/rnn.py:379:25
|
379 | layer.qconfig = getattr(other, "qconfig", qconfig)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR `<=` is not supported between `Literal[0]` and `Number` [unsupported-operation]
--> torch/ao/nn/quantizable/modules/rnn.py:457:20
|
457 | or not 0 <= dropout <= 1
| ^^^^^^^^^^^^^^^^^
|
Argument `Number` is not assignable to parameter `value` with type `int` in function `int.__le__`
ERROR `>` is not supported between `Number` and `Literal[0]` [unsupported-operation]
--> torch/ao/nn/quantizable/modules/rnn.py:465:12
|
465 | if dropout > 0:
| ^^^^^^^^^^^
|
Argument `Number` is not assignable to parameter `value` with type `int` in function `int.__lt__`
ERROR Argument `Any | None` is not assignable to parameter `value` with type `Module | Tensor` in function `torch.nn.modules.module.Module.__setattr__` [bad-argument-type]
--> torch/ao/nn/quantizable/modules/rnn.py:576:28
|
576 | observed.qconfig = getattr(other, "qconfig", qconfig)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR `str | Unknown` is not assignable to variable `padding` with type `int | tuple[int]` [bad-assignment]
--> torch/ao/nn/quantized/dynamic/modules/conv.py:76:19
|
76 | padding = padding if isinstance(padding, str) else _single(padding)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `Tensor` has no attribute `weight` [missing-attribute]
--> torch/ao/nn/quantized/dynamic/modules/linear.py:122:40
|
122 | if mod.qconfig is not None and mod.qconfig.weight is not None:
| ^^^^^^^^^^^^^^^^^^
|
ERROR Expected a callable, got `Tensor` [not-callable]
--> torch/ao/nn/quantized/dynamic/modules/linear.py:123:31
|
123 | weight_observer = mod.qconfig.weight()
| ^^^^^^^^^^^^^^^^^^
|
ERROR Expected a callable, got `object` [not-callable]
--> torch/ao/nn/quantized/dynamic/modules/linear.py:123:31
|
123 | weight_observer = mod.qconfig.weight()
| ^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Module | Tensor | Unknown` is not assignable to parameter `w` with type `Tensor` in function `torch.ao.nn.quantized.modules.linear.Linear.set_weight_bias` [bad-argument-type]
--> torch/ao/nn/quantized/dynamic/modules/linear.py:146:33
|
146 | qlinear.set_weight_bias(qweight, mod.bias)
| ^^^^^^^
|
ERROR Argument `Module | Tensor | Unknown` is not assignable to parameter `b` with type `Tensor | None` in function `torch.ao.nn.quantized.modules.linear.Linear.set_weight_bias` [bad-argument-type]
--> torch/ao/nn/quantized/dynamic/modules/linear.py:146:42
|
146 | qlinear.set_weight_bias(qweight, mod.bias)
| ^^^^^^^^
|
ERROR Class member `LSTM._FLOAT_MODULE` overrides parent class `RNNBase` in an inconsistent manner [bad-override]
--> torch/ao/nn/quantized/dynamic/modules/rnn.py:524:5
|
524 | _FLOAT_MODULE = nn.LSTM
| ^^^^^^^^^^^^^
|
`LSTM._FLOAT_MODULE` has type `type[LSTM]`, which is not consistent with `type[RNNBase]` in `RNNBase._FLOAT_MODULE` (the type of read-write attributes cannot be changed)
ERROR Class member `GRU._FLOAT_MODULE` overrides parent class `RNNBase` in an inconsistent manner [bad-override]
--> torch/ao/nn/quantized/dynamic/modules/rnn.py:809:5
|
809 | _FLOAT_MODULE = nn.GRU
| ^^^^^^^^^^^^^
|
`GRU._FLOAT_MODULE` has type `type[GRU]`, which is not consistent with `type[RNNBase]` in `RNNBase._FLOAT_MODULE` (the type of read-write attributes cannot be changed)
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/activation.py:70:59
|
70 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/activation.py:70:59
|
70 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/activation.py:71:69
|
71 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/activation.py:71:69
|
71 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/activation.py:141:59
|
141 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/activation.py:141:59
|
141 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/activation.py:142:69
|
142 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/activation.py:142:69
|
142 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Class member `MultiheadAttention._FLOAT_MODULE` overrides parent class `MultiheadAttention` in an inconsistent manner [bad-override]
--> torch/ao/nn/quantized/modules/activation.py:229:5
|
229 | _FLOAT_MODULE = torch.ao.nn.quantizable.MultiheadAttention
| ^^^^^^^^^^^^^
|
`MultiheadAttention._FLOAT_MODULE` has type `type[MultiheadAttention]`, which is not consistent with `type[MultiheadAttention]` in `MultiheadAttention._FLOAT_MODULE` (the type of read-write attributes cannot be changed)
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/batchnorm.py:15:57
|
15 | self.register_buffer("scale", torch.tensor(1.0, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/batchnorm.py:15:57
|
15 | self.register_buffer("scale", torch.tensor(1.0, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/batchnorm.py:16:60
|
16 | self.register_buffer("zero_point", torch.tensor(0, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/batchnorm.py:16:60
|
16 | self.register_buffer("zero_point", torch.tensor(0, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR `str | Unknown` is not assignable to variable `padding` with type `int | tuple[int]` [bad-assignment]
--> torch/ao/nn/quantized/modules/conv.py:411:19
|
411 | padding = padding if isinstance(padding, str) else _single(padding)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR `list[Never]` is not assignable to attribute `_FLOAT_MODULE` with type `tuple[type[Linear], type[NonDynamicallyQuantizableLinear]]` [bad-assignment]
--> torch/ao/nn/quantized/modules/linear.py:313:37
|
313 | cls._FLOAT_MODULE = [cls._FLOAT_MODULE]
| ^^^^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `bias` with type `bool` in function `torch.nn.modules.normalization.LayerNorm.__init__` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:40:13
|
40 | **factory_kwargs,
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:44:59
|
44 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:44:59
|
44 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:45:69
|
45 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:45:69
|
45 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:116:59
|
116 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:116:59
|
116 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:117:69
|
117 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:117:69
|
117 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:178:59
|
178 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:178:59
|
178 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:179:69
|
179 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:179:69
|
179 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:245:59
|
245 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:245:59
|
245 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:246:69
|
246 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:246:69
|
246 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:312:59
|
312 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:312:59
|
312 | self.register_buffer("scale", torch.tensor(scale, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `requires_grad` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:313:69
|
313 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR Unpacked keyword argument `Unknown | None` is not assignable to parameter `pin_memory` with type `bool` in function `torch._C._VariableFunctions.tensor` [bad-argument-type]
--> torch/ao/nn/quantized/modules/normalization.py:313:69
|
313 | self.register_buffer("zero_point", torch.tensor(zero_point, **factory_kwargs))
| ^^^^^^^^^^^^^^^^
|
ERROR No matching overload found for function `torch._C._VariableFunctions.conv1d` [no-matching-overload]
--> torch/ao/nn/quantized/reference/modules/conv.py:98:26
|
98 | result = F.conv1d(
| __________________________^
99 | | x,
100 | | weight_quant_dequant,
101 | | self.bias,
102 | | self.stride,
103 | | self.padding,
| |__________________________^
|
Possible overloads:
(input: Tensor, weight: Tensor, bias: Tensor | None = None, stride: Sequence[SymInt | int] | SymInt | int = 1, padding: Sequence[SymInt | int] | SymInt | int = 0, dilation: Sequence[SymInt | int] | SymInt | int = 1, groups: SymInt | int = 1) -> Tensor [closest match]
(input: Tensor, weight: Tensor, bias: Tensor | None = None, stride: Sequence[SymInt | int] | SymInt | int = 1, padding: str = 'valid', dilation: Sequence[SymInt | int] | SymInt | int = 1, groups: SymInt | int = 1) -> Tensor
ERROR Argument `str | Unknown` is not assignable to parameter `padding_mode` with type `Literal['circular', 'reflect', 'replicate', 'zeros']` in function `torch.nn.modules.conv.Conv2d.__init__` [bad-argument-type]
--> torch/ao/nn/quantized/reference/modules/conv.py:143:13
|
143 | padding_mode,
| ^^^^^^^^^^^^
|
ERROR No matching overload found for function `torch._C._VariableFunctions.conv2d` [no-matching-overload]
--> torch/ao/nn/quantized/reference/modules/conv.py:161:26
|
161 | result = F.conv2d(
| __________________________^
162 | | x,
163 | | weight_quant_dequant,
164 | | self.bias,
165 | | self.stride,
166 | | self.padding,
| |__________________________^
|
Possible overloads:
(input: Tensor, weight: Tensor, bias: Tensor | None = None, stride: Sequence[SymInt | int] | SymInt | int = 1, padding: Sequence[SymInt | int] | SymInt | int = 0, dilation: Sequence[SymInt | int] | SymInt | int = 1, groups: SymInt | int = 1) -> Tensor [closest match]
(input: Tensor, weight: Tensor, bias: Tensor | None = None, stride: Sequence[SymInt | int] | SymInt | int = 1, padding: str = 'valid', dilation: Sequence[SymInt | int] | SymInt | int = 1, groups: SymInt | int = 1) -> Tensor
ERROR Argument `str | Unknown` is not assignable to parameter `padding_mode` with type `Literal['circular', 'reflect', 'replicate', 'zeros']` in function `torch.nn.modules.conv.Conv3d.__init__` [bad-argument-type]
--> torch/ao/nn/quantized/reference/modules/conv.py:206:13
|
206 | padding_mode,
| ^^^^^^^^^^^^
|
ERROR No matching overload found for function `torch._C._VariableFunctions.conv3d` [no-matching-overload]
--> torch/ao/nn/quantized/reference/modules/conv.py:224:26
|
224 | result = F.conv3d(
| __________________________^
225 | | x,
226 | | weight_quant_dequant,
227 | | self.bias,
228 | | self.stride,
229 | | self.padding,
| |__________________________^
|
Possible overloads:
(input: Tensor, weight: Tensor, bias: Tensor | None = None, stride: Sequence[SymInt | int] | SymInt | int = 1, padding: Sequence[SymInt | int] | SymInt | int = 0, dilation: Sequence[SymInt | int] | SymInt | int = 1, groups: SymInt | int = 1) -> Tensor [closest match]
(input: Tensor, weight: Tensor, bias: Tensor | None = None, stride: Sequence[SymInt | int] | SymInt | int = 1, padding: str = 'valid', dilation: Sequence[SymInt | int] | SymInt | int = 1, groups: SymInt | int = 1) -> Tensor
ERROR Argument `str | Unknown` is not assignable to parameter `padding_mode` with type `Literal['circular', 'reflect', 'replicate', 'zeros']` in function `torch.nn.modules.conv.ConvTranspose2d.__init__` [bad-argument-type]
--> torch/ao/nn/quantized/reference/modules/conv.py:381:13
|
381 | padding_mode,
| ^^^^^^^^^^^^
|
ERROR Argument `str | Unknown` is not assignable to parameter `padding_mode` with type `Literal['circular', 'reflect', 'replicate', 'zeros']` in function `torch.nn.modules.conv.ConvTranspose3d.__init__` [bad-argument-type]
--> torch/ao/nn/quantized/reference/modules/conv.py:462:13
|
462 | padding_mode,
| ^^^^^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `batch_sizes` with type `Tensor` in function `torch.nn.utils.rnn.PackedSequence.__init__` [bad-argument-type]
--> torch/ao/nn/quantized/reference/modules/rnn.py:666:25
|
666 | output, batch_sizes, sorted_indices, unsorted_indices
| ^^^^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `batch_sizes` with type `Tensor` in function `torch.nn.utils.rnn.PackedSequence.__init__` [bad-argument-type]
--> torch/ao/nn/quantized/reference/modules/rnn.py:826:25
|
826 | output, batch_sizes, sorted_indices, unsorted_indices
| ^^^^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `_freeze` with type `bool` in function `torch.nn.modules.sparse.Embedding.__init__` [bad-argument-type]
--> torch/ao/nn/quantized/reference/modules/sparse.py:45:13
|
45 | device,
| ^^^^^^
|
ERROR `dtype | float | int | qscheme | Unknown` is not assignable to attribute `weight_qscheme` with type `qscheme` [bad-assignment]
--> torch/ao/nn/quantized/reference/modules/utils.py:21:46
|
21 | self.weight_qscheme: torch.qscheme = weight_qparams["qscheme"]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR `dtype | float | int | qscheme | Unknown` is not assignable to attribute `is_decomposed` with type `bool` [bad-assignment]
--> torch/ao/nn/quantized/reference/modules/utils.py:83:36
|
83 | self.is_decomposed: bool = weight_qparams.get("is_decomposed", False)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR `dtype | float | int | qscheme | Unknown | None` is not assignable to attribute `weight_quant_min` with type `int | None` [bad-assignment]
--> torch/ao/nn/quantized/reference/modules/utils.py:87:55
|
87 | self.weight_quant_min: typing.Optional[int] = weight_qparams.get(
| _______________________________________________________^
88 | | "quant_min", None
89 | | )
| |_________^
|
ERROR `dtype | float | int | qscheme | Unknown | None` is not assignable to attribute `weight_quant_max` with type `int | None` [bad-assignment]
--> torch/ao/nn/quantized/reference/modules/utils.py:90:55
|
90 | self.weight_quant_max: typing.Optional[int] = weight_qparams.get(
| _______________________________________________________^
91 | | "quant_max", None
92 | | )
| |_________^
|
ERROR Argument `dtype | float | int | qscheme | Unknown` is not assignable to parameter `weight_dtype` with type `dtype` in function `_quantize_and_dequantize_weight_decomposed` [bad-argument-type]
--> torch/ao/nn/quantized/reference/modules/utils.py:108:17
|
108 | self.weight_dtype,
| ^^^^^^^^^^^^^^^^^
|
ERROR Argument `dtype | float | int | qscheme | Unknown` is not assignable to parameter `weight_dtype` with type `dtype` in function `_quantize_and_dequantize_weight` [bad-argument-type]
--> torch/ao/nn/quantized/reference/modules/utils.py:119:17
|
119 | self.weight_dtype,
| ^^^^^^^^^^^^^^^^^
|
ERROR Argument `dtype | float | int | qscheme | Unknown` is not assignable to parameter `weight_dtype` with type `dtype` in function `_quantize_weight_decomposed` [bad-argument-type]
--> torch/ao/nn/quantized/reference/modules/utils.py:134:17
|
134 | self.weight_dtype,
| ^^^^^^^^^^^^^^^^^
|
ERROR Argument `dtype | float | int | qscheme | Unknown` is not assignable to parameter `weight_dtype` with type `dtype` in function `_quantize_weight` [bad-argument-type]
--> torch/ao/nn/quantized/reference/modules/utils.py:145:17
|
145 | self.weight_dtype,
| ^^^^^^^^^^^^^^^^^
|
ERROR Object of class `Tensor` has no attribute `weight` [missing-attribute]
--> torch/ao/nn/sparse/quantized/dynamic/linear.py:154:40
|
154 | if mod.qconfig is not None and mod.qconfig.weight is not None:
| ^^^^^^^^^^^^^^^^^^
|
ERROR Expected a callable, got `Tensor` [not-callable]
--> torch/ao/nn/sparse/quantized/dynamic/linear.py:155:31
|
155 | weight_observer = mod.qconfig.weight()
| ^^^^^^^^^^^^^^^^^^
|
ERROR Expected a callable, got `object` [not-callable]
--> torch/ao/nn/sparse/quantized/dynamic/linear.py:155:31
|
155 | weight_observer = mod.qconfig.weight()
| ^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Module | Parameter | Tensor` is not assignable to parameter `b` with type `Tensor | None` in function `Linear.set_weight_bias` [bad-argument-type]
--> torch/ao/nn/sparse/quantized/dynamic/linear.py:188:42
|
188 | qlinear.set_weight_bias(qweight, mod.bias, row_block_size, col_block_size)
| ^^^^^^^^
|
ERROR Argument `Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None` is not assignable to parameter `element` with type `Node` in function `set.add` [bad-argument-type]
--> torch/ao/ns/fx/graph_matcher.py:87:45
|
87 | self.seen_nodes.add(cur_start_node)
| ^^^^^^^^^^^^^^
|
ERROR Argument `Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None` is not assignable to parameter `element` with type `Node` in function `set.add` [bad-argument-type]
--> torch/ao/ns/fx/graph_matcher.py:97:33
|
97 | self.seen_nodes.add(cur_start_node)
| ^^^^^^^^^^^^^^
|
ERROR Object of class `Mapping` has no attribute `all_input_nodes`
Object of class `NoneType` has no attribute `all_input_nodes`
Object of class `OpOverload` has no attribute `all_input_nodes`
Object of class `Sequence` has no attribute `all_input_nodes`
Object of class `SymBool` has no attribute `all_input_nodes`
Object of class `SymFloat` has no attribute `all_input_nodes`
Object of class `SymInt` has no attribute `all_input_nodes`
Object of class `Tensor` has no attribute `all_input_nodes`
Object of class `bool` has no attribute `all_input_nodes`
Object of class `complex` has no attribute `all_input_nodes`
Object of class `device` has no attribute `all_input_nodes`
Object of class `dtype` has no attribute `all_input_nodes`
Object of class `float` has no attribute `all_input_nodes`
Object of class `int` has no attribute `all_input_nodes`
Object of class `layout` has no attribute `all_input_nodes`
Object of class `memory_format` has no attribute `all_input_nodes`
Object of class `range` has no attribute `all_input_nodes`
Object of class `slice` has no attribute `all_input_nodes`
Object of class `str` has no attribute `all_input_nodes`
Object of class `tuple` has no attribute `all_input_nodes` [missing-attribute]
--> torch/ao/ns/fx/graph_matcher.py:99:24
|
99 | for arg in cur_start_node.all_input_nodes:
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None` is not assignable to parameter `node` with type `Node` in function `_NSGraphMatchableSubgraphsIterator._is_matchable` [bad-argument-type]
--> torch/ao/ns/fx/graph_matcher.py:106:39
|
106 | if not self._is_matchable(cur_base_op_node):
| ^^^^^^^^^^^^^^^^
|
ERROR Argument `Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None` is not assignable to parameter `start_node` with type `Node` in function `torch.ao.ns.fx.ns_types.NSSubgraph.__new__` [bad-argument-type]
--> torch/ao/ns/fx/graph_matcher.py:119:28
|
119 | start_node=cur_start_node,
| ^^^^^^^^^^^^^^
|
ERROR Argument `Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None` is not assignable to parameter `base_op_node` with type `Node` in function `torch.ao.ns.fx.ns_types.NSSubgraph.__new__` [bad-argument-type]
--> torch/ao/ns/fx/graph_matcher.py:121:30
|
121 | base_op_node=cur_base_op_node,
| ^^^^^^^^^^^^^^^^
|
ERROR Argument `tuple[(...) -> Unknown, ((...) -> Unknown) | None]` is not assignable to parameter `object` with type `tuple[(...) -> Unknown, (...) -> Unknown]` in function `list.append` [bad-argument-type]
--> torch/ao/ns/fx/mappings.py:418:32
|
418 | new_connections.append((source, target2))
| ^^^^^^^^^^^^^^^^^
|
ERROR Argument `tuple[((...) -> Unknown) | str, (...) -> Unknown]` is not assignable to parameter `object` with type `tuple[(...) -> Unknown, (...) -> Unknown]` in function `list.append` [bad-argument-type]
--> torch/ao/ns/fx/mappings.py:426:36
|
426 | new_connections.append((source, target))
| ^^^^^^^^^^^^^^^^
|
ERROR Cannot set item in `dict[str, Node]` [unsupported-operation]
--> torch/ao/ns/fx/n_shadows_utils.py:98:30
|
98 | env[node.name] = result
| ^^^^^^
|
Argument `Tensor | Unknown` is not assignable to parameter `value` with type `Node` in function `dict.__setitem__`
ERROR Object of class `Iterable` has no attribute `append` [missing-attribute]
--> torch/ao/ns/fx/n_shadows_utils.py:396:25
|
396 | cur_args_copy.append(new_arg_placeholder)
| ^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `Iterable` has no attribute `append` [missing-attribute]
--> torch/ao/ns/fx/n_shadows_utils.py:398:25
|
398 | cur_args_copy.append(arg)
| ^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `nodes_in_this_subgraph` with type `list[Any]` in function `create_n_transformed_and_logged_copies_of_subgraph` [bad-argument-type]
--> torch/ao/ns/fx/n_shadows_utils.py:804:17
|
804 | maybe_subgraph,
| ^^^^^^^^^^^^^^
|
ERROR `Node | None` is not assignable to `None` (caused by inconsistent types when breaking cycles) [bad-assignment]
--> torch/ao/ns/fx/n_shadows_utils.py:860:13
|
860 | / while cur_node_orig in subgraph_to_use:
861 | | # TODO(future PR): make this support all possible args/kwargs
862 | | if cur_node_orig is first_node:
863 | | new_args = cur_node_orig.args
864 | | new_kwargs = cur_node_orig.kwargs
865 | | else:
| |______________________^
|
ERROR `Sized | list[dict[str, Any]]` is not assignable to `list[dict[str, Any]]` (caused by inconsistent types when breaking cycles) [bad-assignment]
--> torch/ao/ns/fx/utils.py:407:21
|
407 | / for i in range(len(model_results)):
408 | | fqn = ref_model_results[i]["fqn"]
409 | | model_results[i]["fqn"] = fqn
| |_____________________________________________________^
|
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/ao/ns/fx/utils.py:470:24
|
470 | return torch.sqrt(((x - y) ** 2).sum() / (x**2).sum())
| ^^^^^^^^^^^^
|
Argument `Literal[2]` is not assignable to parameter with type `TensorBase`
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/ao/ns/fx/utils.py:470:24
|
470 | return torch.sqrt(((x - y) ** 2).sum() / (x**2).sum())
| ^^^^^^^^^^^^
|
Expected 1 more positional argument
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/ao/ns/fx/utils.py:470:47
|
470 | return torch.sqrt(((x - y) ** 2).sum() / (x**2).sum())
| ^^^^
|
Argument `Literal[2]` is not assignable to parameter with type `TensorBase`
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/ao/ns/fx/utils.py:470:47
|
470 | return torch.sqrt(((x - y) ** 2).sum() / (x**2).sum())
| ^^^^
|
Expected 1 more positional argument
ERROR Object of class `SparseDLRM` has no attribute `apply_mlp` [missing-attribute]
--> torch/ao/pruning/_experimental/data_sparsifier/benchmarks/dlrm_utils.py:26:13
|
26 | x = self.apply_mlp(dense_x, self.bot_l) # dense features
| ^^^^^^^^^^^^^^
|
ERROR Object of class `SparseDLRM` has no attribute `bot_l` [missing-attribute]
--> torch/ao/pruning/_experimental/data_sparsifier/benchmarks/dlrm_utils.py:26:37
|
26 | x = self.apply_mlp(dense_x, self.bot_l) # dense features
| ^^^^^^^^^^
|
ERROR Object of class `SparseDLRM` has no attribute `apply_emb` [missing-attribute]
--> torch/ao/pruning/_experimental/data_sparsifier/benchmarks/dlrm_utils.py:27:14
|
27 | ly = self.apply_emb(lS_o, lS_i, self.emb_l, self.v_W_l) # apply embedding bag
| ^^^^^^^^^^^^^^
|
ERROR Object of class `SparseDLRM` has no attribute `emb_l` [missing-attribute]
--> torch/ao/pruning/_experimental/data_sparsifier/benchmarks/dlrm_utils.py:27:41
|
27 | ly = self.apply_emb(lS_o, lS_i, self.emb_l, self.v_W_l) # apply embedding bag
| ^^^^^^^^^^
|
ERROR Object of class `SparseDLRM` has no attribute `v_W_l` [missing-attribute]
--> torch/ao/pruning/_experimental/data_sparsifier/benchmarks/dlrm_utils.py:27:53
|
27 | ly = self.apply_emb(lS_o, lS_i, self.emb_l, self.v_W_l) # apply embedding bag
| ^^^^^^^^^^
|
ERROR Object of class `SparseDLRM` has no attribute `interact_features` [missing-attribute]
--> torch/ao/pruning/_experimental/data_sparsifier/benchmarks/dlrm_utils.py:28:13
|
28 | z = self.interact_features(x, ly)
| ^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `SparseDLRM` has no attribute `top_l` [missing-attribute]
--> torch/ao/pruning/_experimental/data_sparsifier/benchmarks/dlrm_utils.py:31:25
|
31 | z = torch.mm(z, self.top_l[0].weight.T).add(self.top_l[0].bias)
| ^^^^^^^^^^
|
ERROR Object of class `SparseDLRM` has no attribute `top_l` [missing-attribute]
--> torch/ao/pruning/_experimental/data_sparsifier/benchmarks/dlrm_utils.py:31:53
|
31 | z = torch.mm(z, self.top_l[0].weight.T).add(self.top_l[0].bias)
| ^^^^^^^^^^
|
ERROR Object of class `SparseDLRM` has no attribute `top_l` [missing-attribute]
--> torch/ao/pruning/_experimental/data_sparsifier/benchmarks/dlrm_utils.py:32:22
|
32 | for layer in self.top_l[1:]:
| ^^^^^^^^^^
|
ERROR Argument `object` is not assignable to parameter `input` with type `Tensor` in function `torch._C._VariableFunctions.abs` [bad-argument-type]
--> torch/ao/pruning/_experimental/pruner/FPGM_pruner.py:75:40
|
75 | distance = torch.sum(torch.abs(dist_matrix), 1)
| ^^^^^^^^^^^
|
ERROR `None` is not assignable to attribute `bias` with type `Parameter` [bad-assignment]
--> torch/ao/pruning/_experimental/pruner/base_structured_sparsifier.py:263:35
|
263 | module.bias = None
| ^^^^
|
ERROR `Parameter` is not assignable to attribute `bias` with type `Never` [bad-assignment]
--> torch/ao/pruning/_experimental/pruner/prune_functions.py:100:23
|
100 | module.bias = nn.Parameter(cast(Tensor, module._bias)[mask])
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Type `None` is not iterable [not-iterable]
--> torch/ao/pruning/sparsifier/base_sparsifier.py:173:30
|
173 | for module_config in self.config:
| ^^^^^^^^^^^
|
ERROR Argument `Iterator[Tensor]` is not assignable to parameter `*iterables` with type `Iterable[Parameter]` in function `itertools.chain.__new__` [bad-argument-type]
--> torch/ao/pruning/sparsifier/utils.py:54:62
|
54 | devices = {p.device for p in chain(mod.parameters(), mod.buffers())}
| ^^^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `shape` [missing-attribute]
--> torch/ao/pruning/sparsifier/weight_norm_sparsifier.py:238:29
|
238 | input_shape=ww.shape,
| ^^^^^^^^
|
WARN `QConfigDynamic` is deprecated [deprecated]
--> torch/ao/quantization/__init__.py:27:22
|
27 | from .qconfig import * # noqa: F403
| -
|
WARN `get_default_qconfig_dict` is deprecated [deprecated]
--> torch/ao/quantization/__init__.py:27:22
|
27 | from .qconfig import * # noqa: F403
| -
|
WARN `get_default_qat_qconfig_dict` is deprecated [deprecated]
--> torch/ao/quantization/__init__.py:27:22
|
27 | from .qconfig import * # noqa: F403
| -
|
ERROR No matching overload found for function `torch._C._VariableFunctions.conv1d` [no-matching-overload]
--> torch/ao/quantization/experimental/adaround_optimization.py:130:45
|
130 | out = torch.nn.functional.conv1d(
| _____________________________________________^
131 | | x,
132 | | weight,
133 | | stride=module.stride,
134 | | padding=module.padding,
135 | | dilation=module.dilation,
| |__________________________________________^
|
Possible overloads:
(input: Tensor, weight: Tensor, bias: Tensor | None = None, stride: Sequence[SymInt | int] | SymInt | int = 1, padding: Sequence[SymInt | int] | SymInt | int = 0, dilation: Sequence[SymInt | int] | SymInt | int = 1, groups: SymInt | int = 1) -> Tensor [closest match]
(input: Tensor, weight: Tensor, bias: Tensor | None = None, stride: Sequence[SymInt | int] | SymInt | int = 1, padding: str = 'valid', dilation: Sequence[SymInt | int] | SymInt | int = 1, groups: SymInt | int = 1) -> Tensor
ERROR Argument `Unknown | None` is not assignable to parameter `dtype` with type `dtype` in function `torch._C.iinfo.__init__` [bad-argument-type]
--> torch/ao/quantization/fake_quantize.py:188:32
|
188 | assert torch.iinfo(dtype).min <= quant_min, "quant_min out of bound"
| ^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `dtype` with type `dtype` in function `torch._C.iinfo.__init__` [bad-argument-type]
--> torch/ao/quantization/fake_quantize.py:189:45
|
189 | assert quant_max <= torch.iinfo(dtype).max, "quant_max out of bound"
| ^^^^^
|
ERROR Class member `FakeQuantPerChannel.forward` overrides parent class `Function` in an inconsistent manner [bad-override]
--> torch/ao/quantization/fx/_decomposed.py:1152:9
|
1152 | def forward(ctx, input, scales, zero_points, axis, quant_min, quant_max):
| ^^^^^^^
|
`FakeQuantPerChannel.forward` has type `(ctx: Unknown, input: Unknown, scales: Unknown, zero_points: Unknown, axis: Unknown, quant_min: Unknown, quant_max: Unknown) -> Unknown`, which is not consistent with `(*args: Any, **kwargs: Any) -> Any` in `Function.forward` (the type of read-write attributes cannot be changed)
ERROR Class member `FakeQuantPerChannel.backward` overrides parent class `Function` in an inconsistent manner [bad-override]
--> torch/ao/quantization/fx/_decomposed.py:1174:9
|
1174 | def backward(ctx, gy):
| ^^^^^^^^
|
`FakeQuantPerChannel.backward` has type `(ctx: Unknown, gy: Unknown) -> Unknown`, which is not consistent with `(ctx: Any, *grad_outputs: Any) -> Any` in `Function.backward` (the type of read-write attributes cannot be changed)
ERROR Invalid expression form for base class: `namedtuple("EqualizationQConfig", ["input_activation", "weight"])` [invalid-inheritance]
--> torch/ao/quantization/fx/_equalize.py:249:5
|
249 | namedtuple("EqualizationQConfig", ["input_activation", "weight"])
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR The `__bool__` attribute of `_InputEqualizationObserver | None` has type `BoundMethod[NoneType, (self: NoneType) -> Literal[False]] | Module | Tensor`, which is not callable [invalid-argument]
--> torch/ao/quantization/fx/_equalize.py:463:8
|
463 | if next_inp_eq_obs:
| ^^^^^^^^^^^^^^^
|
ERROR Argument `Tensor | None` is not assignable to parameter `equalization_scale` with type `Tensor` in function `scale_weight_node` [bad-argument-type]
--> torch/ao/quantization/fx/_equalize.py:824:36
|
824 | node, modules, equalization_scale, maybe_next_equalization_scale
| ^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Tensor | None` is not assignable to parameter `equalization_scale` with type `Tensor` in function `scale_weight_functional` [bad-argument-type]
--> torch/ao/quantization/fx/_equalize.py:831:21
|
831 | equalization_scale,
| ^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Literal['Not Applicable'] | bool | float | int | Any` is not assignable to parameter `object` with type `int | str` in function `list.append` [bad-argument-type]
--> torch/ao/quantization/fx/_model_report/model_report_visualizer.py:226:45
|
226 | tensor_table_row.append(feature_val)
| ^^^^^^^^^^^
|
ERROR Argument `Literal['Not Applicable'] | bool | float | int | Unknown` is not assignable to parameter `object` with type `int | str` in function `list.append` [bad-argument-type]
--> torch/ao/quantization/fx/_model_report/model_report_visualizer.py:286:48
|
286 | new_channel_row.append(feature_val)
| ^^^^^^^^^^^
|
ERROR Cannot set item in `dict[str, ((list[FakeQuantizeBase | ObserverBase]) -> tuple[Tensor, Tensor]) | dtype | int | qscheme | None]` [unsupported-operation]
--> torch/ao/quantization/fx/prepare.py:169:32
|
169 | kwargs["obs_or_fqs"] = obs_or_fqs
| ^^^^^^^^^^
|
Argument `list[FakeQuantizeBase | ObserverBase]` is not assignable to parameter `value` with type `((list[FakeQuantizeBase | ObserverBase]) -> tuple[Tensor, Tensor]) | dtype | int | qscheme | None` in function `dict.__setitem__`
ERROR Argument `QConfigMapping | dict[str, Any]` is not assignable to parameter `qconfig_mapping` with type `QConfigMapping` in function `torch.ao.quantization.fx.qconfig_mapping_utils._update_qconfig_for_fusion` [bad-argument-type]
--> torch/ao/quantization/fx/prepare.py:2088:39
|
2088 | _update_qconfig_for_fusion(model, qconfig_mapping)
| ^^^^^^^^^^^^^^^
|
ERROR Argument `QConfigMapping | dict[str, Any] | None` is not assignable to parameter `qconfig_mapping` with type `QConfigMapping` in function `torch.ao.quantization.fx.qconfig_mapping_utils._update_qconfig_for_fusion` [bad-argument-type]
--> torch/ao/quantization/fx/prepare.py:2089:39
|
2089 | _update_qconfig_for_fusion(model, _equalization_config)
| ^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `QConfigMapping | dict[str, Any]` is not assignable to parameter `qconfig_mapping` with type `QConfigMapping` in function `torch.ao.quantization.fx.qconfig_mapping_utils._get_flattened_qconfig_dict` [bad-argument-type]
--> torch/ao/quantization/fx/prepare.py:2090:58
|
2090 | flattened_qconfig_dict = _get_flattened_qconfig_dict(qconfig_mapping)
| ^^^^^^^^^^^^^^^
|
ERROR Argument `QConfigMapping | dict[str, Any]` is not assignable to parameter `qconfig_mapping` with type `QConfigMapping` in function `torch.ao.quantization.fx.qconfig_mapping_utils._update_qconfig_for_qat` [bad-argument-type]
--> torch/ao/quantization/fx/prepare.py:2097:33
|
2097 | _update_qconfig_for_qat(qconfig_mapping, backend_config)
| ^^^^^^^^^^^^^^^
|
ERROR Argument `QConfigMapping | dict[str, Any] | None` is not assignable to parameter `qconfig_mapping` with type `QConfigMapping` in function `torch.ao.quantization.fx.qconfig_mapping_utils._generate_node_name_to_qconfig` [bad-argument-type]
--> torch/ao/quantization/fx/prepare.py:2110:44
|
2110 | model, named_modules, model.graph, _equalization_config, node_name_to_scope
| ^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `QConfigMapping | dict[str, Any]` is not assignable to parameter `qconfig_mapping` with type `QConfigMapping` in function `torch.ao.quantization.fx.qconfig_mapping_utils._generate_node_name_to_qconfig` [bad-argument-type]
--> torch/ao/quantization/fx/prepare.py:2113:44
|
2113 | model, named_modules, model.graph, qconfig_mapping, node_name_to_scope
| ^^^^^^^^^^^^^^^
|
ERROR Argument `QConfigMapping | dict[str, Any]` is not assignable to parameter `qconfig_mapping` with type `QConfigMapping` in function `_save_state` [bad-argument-type]
--> torch/ao/quantization/fx/prepare.py:2173:9
|
2173 | qconfig_mapping,
| ^^^^^^^^^^^^^^^
|
ERROR Returned type `Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | Unknown | None` is not assignable to declared return type `Node | None` [bad-return]
--> torch/ao/quantization/fx/utils.py:723:16
|
723 | return a
| ^
|
ERROR Argument `Unknown | None` is not assignable to parameter `quant_min` with type `int` in function `torch.ao.quantization.utils.validate_qmin_qmax` [bad-argument-type]
--> torch/ao/quantization/observer.py:283:32
|
283 | validate_qmin_qmax(quant_min, quant_max)
| ^^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `quant_max` with type `int` in function `torch.ao.quantization.utils.validate_qmin_qmax` [bad-argument-type]
--> torch/ao/quantization/observer.py:283:43
|
283 | validate_qmin_qmax(quant_min, quant_max)
| ^^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `quant_min` with type `int` in function `torch.ao.quantization.utils.calculate_qmin_qmax` [bad-argument-type]
--> torch/ao/quantization/observer.py:285:13
|
285 | quant_min,
| ^^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `quant_max` with type `int` in function `torch.ao.quantization.utils.calculate_qmin_qmax` [bad-argument-type]
--> torch/ao/quantization/observer.py:286:13
|
286 | quant_max,
| ^^^^^^^^^
|
ERROR `Node | str` is not assignable to `str` (caused by inconsistent types when breaking cycles) [bad-assignment]
--> torch/ao/quantization/pt2e/utils.py:75:9
|
75 | / for n in user.kwargs:
76 | | if (
77 | | isinstance(n, torch.fx.Node)
78 | | and n.op == "call_function"
79 | | and n.target in _DEQUANTIZE_OPS
80 | | ):
| |_______________^
|
ERROR Invalid expression form for base class: `namedtuple("QConfig", ["activation", "weight"])` [invalid-inheritance]
--> torch/ao/quantization/qconfig.py:86:15
|
86 | class QConfig(namedtuple("QConfig", ["activation", "weight"])):
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Invalid expression form for base class: `namedtuple("QConfigDynamic", ["activation", "weight"])` [invalid-inheritance]
--> torch/ao/quantization/qconfig.py:123:22
|
123 | class QConfigDynamic(namedtuple("QConfigDynamic", ["activation", "weight"])):
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR `bool | None` is not assignable to `None` (caused by inconsistent types when breaking cycles) [bad-assignment]
--> torch/ao/quantization/quantizer/x86_inductor_quantizer.py:420:9
|
420 | / for qconfig in (
421 | | list(self.module_name_qconfig.values())
422 | | + list(self.operator_type_qconfig.values())
423 | | + [self.global_config]
424 | | ):
425 | | if qconfig is not None:
| |____________________________________^
|
ERROR Argument `dict[Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None, Unknown]` is not assignable to parameter `input_qspec_map` with type `dict[Node, QuantizationSpecBase | None]` in function `_X86InductorQuantizationAnnotation.__init__` [bad-argument-type]
--> torch/ao/quantization/quantizer/x86_inductor_quantizer.py:811:41
|
811 | input_qspec_map=binary_node_input_qspec_map,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `dict[Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None, Unknown]` is not assignable to parameter `input_qspec_map` with type `dict[Node, QuantizationSpecBase | None]` in function `_X86InductorQuantizationAnnotation.__init__` [bad-argument-type]
--> torch/ao/quantization/quantizer/x86_inductor_quantizer.py:881:41
|
881 | input_qspec_map=binary_node_input_qspec_map,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `dict[Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None, Unknown]` is not assignable to parameter `input_qspec_map` with type `dict[Node, QuantizationSpecBase | None]` in function `_X86InductorQuantizationAnnotation.__init__` [bad-argument-type]
--> torch/ao/quantization/quantizer/x86_inductor_quantizer.py:1088:33
|
1088 | input_qspec_map=binary_node_input_qspec_map,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `dict[Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None, Unknown]` is not assignable to parameter `input_qspec_map` with type `dict[Node, QuantizationSpecBase | None]` in function `_X86InductorQuantizationAnnotation.__init__` [bad-argument-type]
--> torch/ao/quantization/quantizer/x86_inductor_quantizer.py:1142:33
|
1142 | input_qspec_map=binary_node_input_qspec_map,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `type[ReLU] | None` is not assignable to parameter `object` with type `((a: Any, b: Any, /) -> Any) | type[Linear]` in function `list.append` [bad-argument-type]
--> torch/ao/quantization/quantizer/x86_inductor_quantizer.py:1502:38
|
1502 | seq_partition.append(unary_op)
| ^^^^^^^^
|
ERROR Argument `list[Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | Unknown | None]` is not assignable to parameter `nodes` with type `list[Node]` in function `_is_annotated` [bad-argument-type]
--> torch/ao/quantization/quantizer/xnnpack_quantizer_utils.py:379:26
|
379 | if _is_annotated(partition):
| ^^^^^^^^^
|
ERROR Argument `Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | Unknown | None` is not assignable to parameter with type `Node` [bad-argument-type]
--> torch/ao/quantization/quantizer/xnnpack_quantizer_utils.py:382:44
|
382 | if filter_fn and any(not filter_fn(n) for n in partition):
| ^
|
ERROR Argument `list[Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | Unknown | None]` is not assignable to parameter `nodes` with type `list[Node]` in function `_mark_nodes_as_annotated` [bad-argument-type]
--> torch/ao/quantization/quantizer/xnnpack_quantizer_utils.py:392:34
|
392 | _mark_nodes_as_annotated(partition)
| ^^^^^^^^^
|
ERROR Class member `Bernoulli.arg_constraints` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/bernoulli.py:42:5
|
42 | arg_constraints = {"probs": constraints.unit_interval, "logits": constraints.real}
| ^^^^^^^^^^^^^^^
|
`Bernoulli.arg_constraints` has type `dict[str, _Interval | _Real]`, which is not assignable to `BoundMethod[Bernoulli, (self: Bernoulli) -> dict[str, Constraint]]`, the property getter for `ExponentialFamily.arg_constraints`
ERROR Attribute `probs` of class `Bernoulli` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/bernoulli.py:59:14
|
59 | (self.probs,) = broadcast_all(probs)
| ^^^^^^^^^^
|
ERROR Attribute `logits` of class `Bernoulli` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/bernoulli.py:63:14
|
63 | (self.logits,) = broadcast_all(logits)
| ^^^^^^^^^^^
|
ERROR Class member `Bernoulli._log_normalizer` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/bernoulli.py:140:9
|
140 | def _log_normalizer(self, x):
| ^^^^^^^^^^^^^^^
|
`Bernoulli._log_normalizer` has type `BoundMethod[Bernoulli, (self: Bernoulli, x: Unknown) -> Unknown]`, which is not assignable to `BoundMethod[Bernoulli, (self: Bernoulli, *natural_params: Unknown) -> Unknown]`, the type of `ExponentialFamily._log_normalizer`
ERROR Class member `Beta.arg_constraints` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/beta.py:34:5
|
34 | arg_constraints = {
| ^^^^^^^^^^^^^^^
|
`Beta.arg_constraints` has type `dict[str, _GreaterThan]`, which is not assignable to `BoundMethod[Beta, (self: Beta) -> dict[str, Constraint]]`, the property getter for `ExponentialFamily.arg_constraints`
ERROR Class member `Beta._log_normalizer` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/beta.py:116:9
|
116 | def _log_normalizer(self, x, y):
| ^^^^^^^^^^^^^^^
|
`Beta._log_normalizer` has type `BoundMethod[Beta, (self: Beta, x: Unknown, y: Unknown) -> Unknown]`, which is not assignable to `BoundMethod[Beta, (self: Beta, *natural_params: Unknown) -> Unknown]`, the type of `ExponentialFamily._log_normalizer`
ERROR Class member `Binomial.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/binomial.py:48:5
|
48 | arg_constraints = {
| ^^^^^^^^^^^^^^^
|
`Binomial.arg_constraints` has type `dict[str, _IntegerGreaterThan | _Interval | _Real]`, which is not assignable to `BoundMethod[Binomial, (self: Binomial) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Attribute `probs` of class `Binomial` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/binomial.py:69:17
|
69 | self.probs,
| ^^^^^^^^^^
|
ERROR Attribute `logits` of class `Binomial` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/binomial.py:76:17
|
76 | self.logits,
| ^^^^^^^^^^^
|
ERROR Class member `Binomial.support` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/binomial.py:102:9
|
102 | def support(self):
| ^^^^^^^
|
`Binomial.support` and `Distribution.support` must both be descriptors
ERROR Class member `Categorical.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/categorical.py:53:5
|
53 | arg_constraints = {"probs": constraints.simplex, "logits": constraints.real_vector}
| ^^^^^^^^^^^^^^^
|
`Categorical.arg_constraints` has type `dict[str, _IndependentConstraint | _Simplex]`, which is not assignable to `BoundMethod[Categorical, (self: Categorical) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Attribute `probs` of class `Categorical` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/categorical.py:69:13
|
69 | self.probs = probs / probs.sum(-1, keepdim=True)
| ^^^^^^^^^^
|
ERROR Attribute `logits` of class `Categorical` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/categorical.py:75:13
|
75 | self.logits = logits - logits.logsumexp(dim=-1, keepdim=True)
| ^^^^^^^^^^^
|
ERROR Class member `Categorical.support` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/categorical.py:102:9
|
102 | def support(self):
| ^^^^^^^
|
`Categorical.support` and `Distribution.support` must both be descriptors
ERROR Class member `Cauchy.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/cauchy.py:34:5
|
34 | arg_constraints = {"loc": constraints.real, "scale": constraints.positive}
| ^^^^^^^^^^^^^^^
|
`Cauchy.arg_constraints` has type `dict[str, _GreaterThan | _Real]`, which is not assignable to `BoundMethod[Cauchy, (self: Cauchy) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Class member `ContinuousBernoulli.arg_constraints` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/continuous_bernoulli.py:50:5
|
50 | arg_constraints = {"probs": constraints.unit_interval, "logits": constraints.real}
| ^^^^^^^^^^^^^^^
|
`ContinuousBernoulli.arg_constraints` has type `dict[str, _Interval | _Real]`, which is not assignable to `BoundMethod[ContinuousBernoulli, (self: ContinuousBernoulli) -> dict[str, Constraint]]`, the property getter for `ExponentialFamily.arg_constraints`
ERROR Attribute `probs` of class `ContinuousBernoulli` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/continuous_bernoulli.py:68:14
|
68 | (self.probs,) = broadcast_all(probs)
| ^^^^^^^^^^
|
ERROR Attribute `probs` of class `ContinuousBernoulli` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/continuous_bernoulli.py:74:13
|
74 | self.probs = clamp_probs(self.probs)
| ^^^^^^^^^^
|
ERROR Attribute `logits` of class `ContinuousBernoulli` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/continuous_bernoulli.py:78:14
|
78 | (self.logits,) = broadcast_all(logits)
| ^^^^^^^^^^^
|
ERROR Class member `ContinuousBernoulli._log_normalizer` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/continuous_bernoulli.py:233:9
|
233 | def _log_normalizer(self, x):
| ^^^^^^^^^^^^^^^
|
`ContinuousBernoulli._log_normalizer` has type `BoundMethod[ContinuousBernoulli, (self: ContinuousBernoulli, x: Unknown) -> Unknown]`, which is not assignable to `BoundMethod[ContinuousBernoulli, (self: ContinuousBernoulli, *natural_params: Unknown) -> Unknown]`, the type of `ExponentialFamily._log_normalizer`
ERROR Class member `_Dirichlet.forward` overrides parent class `Function` in an inconsistent manner [bad-override]
--> torch/distributions/dirichlet.py:25:9
|
25 | def forward(ctx, concentration):
| ^^^^^^^
|
`_Dirichlet.forward` has type `(ctx: Unknown, concentration: Unknown) -> Unknown`, which is not consistent with `(*args: Any, **kwargs: Any) -> Any` in `Function.forward` (the type of read-write attributes cannot be changed)
ERROR Class member `_Dirichlet.backward` overrides parent class `Function` in an inconsistent manner [bad-override]
--> torch/distributions/dirichlet.py:32:9
|
32 | def backward(ctx, grad_output):
| ^^^^^^^^
|
`_Dirichlet.backward` has type `(Unknown, grad_output: Unknown) -> Unknown`, which is not consistent with `(ctx: Any, *grad_outputs: Any) -> Any` in `Function.backward` (the type of read-write attributes cannot be changed)
ERROR Class member `Dirichlet.arg_constraints` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/dirichlet.py:53:5
|
53 | arg_constraints = {
| ^^^^^^^^^^^^^^^
|
`Dirichlet.arg_constraints` has type `dict[str, _IndependentConstraint]`, which is not assignable to `BoundMethod[Dirichlet, (self: Dirichlet) -> dict[str, Constraint]]`, the property getter for `ExponentialFamily.arg_constraints`
ERROR Class member `Dirichlet._log_normalizer` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/dirichlet.py:133:9
|
133 | def _log_normalizer(self, x):
| ^^^^^^^^^^^^^^^
|
`Dirichlet._log_normalizer` has type `BoundMethod[Dirichlet, (self: Dirichlet, x: Unknown) -> Unknown]`, which is not assignable to `BoundMethod[Dirichlet, (self: Dirichlet, *natural_params: Unknown) -> Unknown]`, the type of `ExponentialFamily._log_normalizer`
ERROR Class member `Exponential.arg_constraints` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/exponential.py:30:5
|
30 | arg_constraints = {"rate": constraints.positive}
| ^^^^^^^^^^^^^^^
|
`Exponential.arg_constraints` has type `dict[str, _GreaterThan]`, which is not assignable to `BoundMethod[Exponential, (self: Exponential) -> dict[str, Constraint]]`, the property getter for `ExponentialFamily.arg_constraints`
ERROR Class member `Exponential._log_normalizer` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/exponential.py:92:9
|
92 | def _log_normalizer(self, x):
| ^^^^^^^^^^^^^^^
|
`Exponential._log_normalizer` has type `BoundMethod[Exponential, (self: Exponential, x: Unknown) -> Unknown]`, which is not assignable to `BoundMethod[Exponential, (self: Exponential, *natural_params: Unknown) -> Unknown]`, the type of `ExponentialFamily._log_normalizer`
ERROR Class member `FisherSnedecor.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/fishersnedecor.py:32:5
|
32 | arg_constraints = {"df1": constraints.positive, "df2": constraints.positive}
| ^^^^^^^^^^^^^^^
|
`FisherSnedecor.arg_constraints` has type `dict[str, _GreaterThan]`, which is not assignable to `BoundMethod[FisherSnedecor, (self: FisherSnedecor) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Class member `Gamma.arg_constraints` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/gamma.py:37:5
|
37 | arg_constraints = {
| ^^^^^^^^^^^^^^^
|
`Gamma.arg_constraints` has type `dict[str, _GreaterThan]`, which is not assignable to `BoundMethod[Gamma, (self: Gamma) -> dict[str, Constraint]]`, the property getter for `ExponentialFamily.arg_constraints`
ERROR Class member `Gamma._log_normalizer` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/gamma.py:112:9
|
112 | def _log_normalizer(self, x, y):
| ^^^^^^^^^^^^^^^
|
`Gamma._log_normalizer` has type `BoundMethod[Gamma, (self: Gamma, x: Unknown, y: Unknown) -> Unknown]`, which is not assignable to `BoundMethod[Gamma, (self: Gamma, *natural_params: Unknown) -> Unknown]`, the type of `ExponentialFamily._log_normalizer`
ERROR Class member `GeneralizedPareto.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/generalized_pareto.py:38:5
|
38 | arg_constraints = {
| ^^^^^^^^^^^^^^^
|
`GeneralizedPareto.arg_constraints` has type `dict[str, _GreaterThan | _Real]`, which is not assignable to `BoundMethod[GeneralizedPareto, (self: GeneralizedPareto) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/generalized_pareto.py:133:18
|
133 | result = self.scale**2 / ((1 - safe_conc) ** 2 * (1 - 2 * safe_conc))
| ^^^^^^^^^^^^^
|
Argument `Literal[2]` is not assignable to parameter with type `TensorBase`
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/generalized_pareto.py:133:18
|
133 | result = self.scale**2 / ((1 - safe_conc) ** 2 * (1 - 2 * safe_conc))
| ^^^^^^^^^^^^^
|
Expected 1 more positional argument
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/generalized_pareto.py:133:35
|
133 | result = self.scale**2 / ((1 - safe_conc) ** 2 * (1 - 2 * safe_conc))
| ^^^^^^^^^^^^^^^^^^^^
|
Argument `Literal[2]` is not assignable to parameter with type `TensorBase`
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/generalized_pareto.py:133:35
|
133 | result = self.scale**2 / ((1 - safe_conc) ** 2 * (1 - 2 * safe_conc))
| ^^^^^^^^^^^^^^^^^^^^
|
Expected 1 more positional argument
ERROR Class member `GeneralizedPareto.support` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/generalized_pareto.py:145:9
|
145 | def support(self):
| ^^^^^^^
|
`GeneralizedPareto.support` and `Distribution.support` must both be descriptors
ERROR Class member `Geometric.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/geometric.py:47:5
|
47 | arg_constraints = {"probs": constraints.unit_interval, "logits": constraints.real}
| ^^^^^^^^^^^^^^^
|
`Geometric.arg_constraints` has type `dict[str, _Interval | _Real]`, which is not assignable to `BoundMethod[Geometric, (self: Geometric) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Attribute `probs` of class `Geometric` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/geometric.py:61:14
|
61 | (self.probs,) = broadcast_all(probs)
| ^^^^^^^^^^
|
ERROR Attribute `logits` of class `Geometric` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/geometric.py:64:14
|
64 | (self.logits,) = broadcast_all(logits)
| ^^^^^^^^^^^
|
ERROR Class member `Gumbel.support` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/gumbel.py:35:5
|
35 | support = constraints.real
| ^^^^^^^
|
`Gumbel.support` and `TransformedDistribution.support` must both be descriptors
ERROR Class member `HalfCauchy.support` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/half_cauchy.py:35:5
|
35 | support = constraints.nonnegative
| ^^^^^^^
|
`HalfCauchy.support` and `TransformedDistribution.support` must both be descriptors
ERROR Class member `HalfCauchy.base_dist` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/half_cauchy.py:37:5
|
37 | base_dist: Cauchy
| ^^^^^^^^^
|
`HalfCauchy.base_dist` has type `Cauchy`, which is not consistent with `Distribution | Independent[Distribution | Unknown] | Unknown` in `TransformedDistribution.base_dist` (the type of read-write attributes cannot be changed)
ERROR Class member `HalfNormal.support` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/half_normal.py:35:5
|
35 | support = constraints.nonnegative
| ^^^^^^^
|
`HalfNormal.support` and `TransformedDistribution.support` must both be descriptors
ERROR Class member `HalfNormal.base_dist` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/half_normal.py:37:5
|
37 | base_dist: Normal
| ^^^^^^^^^
|
`HalfNormal.base_dist` has type `Normal`, which is not consistent with `Distribution | Independent[Distribution | Unknown] | Unknown` in `TransformedDistribution.base_dist` (the type of read-write attributes cannot be changed)
ERROR Class member `Independent.support` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/independent.py:94:9
|
94 | def support(self):
| ^^^^^^^
|
`Independent.support` and `Distribution.support` must both be descriptors
ERROR Class member `InverseGamma.support` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/inverse_gamma.py:41:5
|
41 | support = constraints.positive
| ^^^^^^^
|
`InverseGamma.support` and `TransformedDistribution.support` must both be descriptors
ERROR Class member `InverseGamma.base_dist` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/inverse_gamma.py:43:5
|
43 | base_dist: Gamma
| ^^^^^^^^^
|
`InverseGamma.base_dist` has type `Gamma`, which is not consistent with `Distribution | Independent[Distribution | Unknown] | Unknown` in `TransformedDistribution.base_dist` (the type of read-write attributes cannot be changed)
ERROR Class member `Kumaraswamy.support` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/kumaraswamy.py:47:5
|
47 | support = constraints.unit_interval
| ^^^^^^^
|
`Kumaraswamy.support` and `TransformedDistribution.support` must both be descriptors
ERROR Argument `list[AffineTransform | PowerTransform]` is not assignable to parameter `transforms` with type `Transform | list[Transform]` in function `torch.distributions.transformed_distribution.TransformedDistribution.__init__` [bad-argument-type]
--> torch/distributions/kumaraswamy.py:69:37
|
69 | super().__init__(base_dist, transforms, validate_args=validate_args)
| ^^^^^^^^^^
|
ERROR Class member `Laplace.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/laplace.py:31:5
|
31 | arg_constraints = {"loc": constraints.real, "scale": constraints.positive}
| ^^^^^^^^^^^^^^^
|
`Laplace.arg_constraints` has type `dict[str, _GreaterThan | _Real]`, which is not assignable to `BoundMethod[Laplace, (self: Laplace) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Class member `LKJCholesky.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/lkj_cholesky.py:63:5
|
63 | arg_constraints = {"concentration": constraints.positive}
| ^^^^^^^^^^^^^^^
|
`LKJCholesky.arg_constraints` has type `dict[str, _GreaterThan]`, which is not assignable to `BoundMethod[LKJCholesky, (self: LKJCholesky) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Class member `LogNormal.support` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/log_normal.py:35:5
|
35 | support = constraints.positive
| ^^^^^^^
|
`LogNormal.support` and `TransformedDistribution.support` must both be descriptors
ERROR Class member `LogNormal.base_dist` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/log_normal.py:37:5
|
37 | base_dist: Normal
| ^^^^^^^^^
|
`LogNormal.base_dist` has type `Normal`, which is not consistent with `Distribution | Independent[Distribution | Unknown] | Unknown` in `TransformedDistribution.base_dist` (the type of read-write attributes cannot be changed)
ERROR Class member `LogisticNormal.support` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/logistic_normal.py:39:5
|
39 | support = constraints.simplex
| ^^^^^^^
|
`LogisticNormal.support` and `TransformedDistribution.support` must both be descriptors
ERROR Class member `LogisticNormal.base_dist` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/logistic_normal.py:41:5
|
41 | base_dist: Independent[Normal]
| ^^^^^^^^^
|
`LogisticNormal.base_dist` has type `Independent[Normal]`, which is not consistent with `Distribution | Independent[Distribution | Unknown] | Unknown` in `TransformedDistribution.base_dist` (the type of read-write attributes cannot be changed)
ERROR Class member `LowRankMultivariateNormal.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/lowrank_multivariate_normal.py:89:5
|
89 | arg_constraints = {
| ^^^^^^^^^^^^^^^
|
`LowRankMultivariateNormal.arg_constraints` has type `dict[str, _IndependentConstraint]`, which is not assignable to `BoundMethod[LowRankMultivariateNormal, (self: LowRankMultivariateNormal) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Class member `MixtureSameFamily.support` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/mixture_same_family.py:127:9
|
127 | def support(self):
| ^^^^^^^
|
`MixtureSameFamily.support` and `Distribution.support` must both be descriptors
ERROR Class member `Multinomial.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/multinomial.py:53:5
|
53 | arg_constraints = {"probs": constraints.simplex, "logits": constraints.real_vector}
| ^^^^^^^^^^^^^^^
|
`Multinomial.arg_constraints` has type `dict[str, _IndependentConstraint | _Simplex]`, which is not assignable to `BoundMethod[Multinomial, (self: Multinomial) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Class member `Multinomial.support` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/multinomial.py:95:9
|
95 | def support(self):
| ^^^^^^^
|
`Multinomial.support` and `Distribution.support` must both be descriptors
ERROR Class member `MultivariateNormal.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/multivariate_normal.py:126:5
|
126 | arg_constraints = {
| ^^^^^^^^^^^^^^^
|
`MultivariateNormal.arg_constraints` has type `dict[str, _IndependentConstraint | _LowerCholesky | _PositiveDefinite]`, which is not assignable to `BoundMethod[MultivariateNormal, (self: MultivariateNormal) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Attribute `scale_tril` of class `MultivariateNormal` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/multivariate_normal.py:159:13
|
159 | self.scale_tril = scale_tril.expand(batch_shape + (-1, -1))
| ^^^^^^^^^^^^^^^
|
ERROR Attribute `covariance_matrix` of class `MultivariateNormal` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/multivariate_normal.py:169:13
|
169 | self.covariance_matrix = covariance_matrix.expand(batch_shape + (-1, -1))
| ^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Attribute `precision_matrix` of class `MultivariateNormal` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/multivariate_normal.py:180:13
|
180 | self.precision_matrix = precision_matrix.expand(batch_shape + (-1, -1))
| ^^^^^^^^^^^^^^^^^^^^^
|
ERROR Class member `NegativeBinomial.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/negative_binomial.py:36:5
|
36 | arg_constraints = {
| ^^^^^^^^^^^^^^^
|
`NegativeBinomial.arg_constraints` has type `dict[str, _GreaterThanEq | _HalfOpenInterval | _Real]`, which is not assignable to `BoundMethod[NegativeBinomial, (self: NegativeBinomial) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Attribute `probs` of class `NegativeBinomial` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/negative_binomial.py:57:17
|
57 | self.probs,
| ^^^^^^^^^^
|
ERROR Attribute `logits` of class `NegativeBinomial` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/negative_binomial.py:64:17
|
64 | self.logits,
| ^^^^^^^^^^^
|
ERROR Class member `Normal.arg_constraints` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/normal.py:34:5
|
34 | arg_constraints = {"loc": constraints.real, "scale": constraints.positive}
| ^^^^^^^^^^^^^^^
|
`Normal.arg_constraints` has type `dict[str, _GreaterThan | _Real]`, which is not assignable to `BoundMethod[Normal, (self: Normal) -> dict[str, Constraint]]`, the property getter for `ExponentialFamily.arg_constraints`
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/normal.py:91:15
|
91 | var = self.scale**2
| ^^^^^^^^^^^^^
|
Argument `Literal[2]` is not assignable to parameter with type `TensorBase`
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/normal.py:91:15
|
91 | var = self.scale**2
| ^^^^^^^^^^^^^
|
Expected 1 more positional argument
ERROR Class member `Normal._log_normalizer` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/normal.py:120:9
|
120 | def _log_normalizer(self, x, y):
| ^^^^^^^^^^^^^^^
|
`Normal._log_normalizer` has type `BoundMethod[Normal, (self: Normal, x: Unknown, y: Unknown) -> Unknown]`, which is not assignable to `BoundMethod[Normal, (self: Normal, *natural_params: Unknown) -> Unknown]`, the type of `ExponentialFamily._log_normalizer`
ERROR Class member `OneHotCategorical.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/one_hot_categorical.py:45:5
|
45 | arg_constraints = {"probs": constraints.simplex, "logits": constraints.real_vector}
| ^^^^^^^^^^^^^^^
|
`OneHotCategorical.arg_constraints` has type `dict[str, _IndependentConstraint | _Simplex]`, which is not assignable to `BoundMethod[OneHotCategorical, (self: OneHotCategorical) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Argument `list[AffineTransform | ExpTransform]` is not assignable to parameter `transforms` with type `Transform | list[Transform]` in function `torch.distributions.transformed_distribution.TransformedDistribution.__init__` [bad-argument-type]
--> torch/distributions/pareto.py:42:37
|
42 | super().__init__(base_dist, transforms, validate_args=validate_args)
| ^^^^^^^^^^
|
ERROR Class member `Poisson.arg_constraints` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/poisson.py:35:5
|
35 | arg_constraints = {"rate": constraints.nonnegative}
| ^^^^^^^^^^^^^^^
|
`Poisson.arg_constraints` has type `dict[str, _GreaterThanEq]`, which is not assignable to `BoundMethod[Poisson, (self: Poisson) -> dict[str, Constraint]]`, the property getter for `ExponentialFamily.arg_constraints`
ERROR Class member `Poisson._log_normalizer` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/poisson.py:85:9
|
85 | def _log_normalizer(self, x):
| ^^^^^^^^^^^^^^^
|
`Poisson._log_normalizer` has type `BoundMethod[Poisson, (self: Poisson, x: Unknown) -> Unknown]`, which is not assignable to `BoundMethod[Poisson, (self: Poisson, *natural_params: Unknown) -> Unknown]`, the type of `ExponentialFamily._log_normalizer`
ERROR Class member `LogitRelaxedBernoulli.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/relaxed_bernoulli.py:43:5
|
43 | arg_constraints = {"probs": constraints.unit_interval, "logits": constraints.real}
| ^^^^^^^^^^^^^^^
|
`LogitRelaxedBernoulli.arg_constraints` has type `dict[str, _Interval | _Real]`, which is not assignable to `BoundMethod[LogitRelaxedBernoulli, (self: LogitRelaxedBernoulli) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Attribute `probs` of class `LogitRelaxedBernoulli` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/relaxed_bernoulli.py:60:14
|
60 | (self.probs,) = broadcast_all(probs)
| ^^^^^^^^^^
|
ERROR Attribute `logits` of class `LogitRelaxedBernoulli` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/relaxed_bernoulli.py:64:14
|
64 | (self.logits,) = broadcast_all(logits)
| ^^^^^^^^^^^
|
ERROR Class member `RelaxedBernoulli.support` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/relaxed_bernoulli.py:141:5
|
141 | support = constraints.unit_interval
| ^^^^^^^
|
`RelaxedBernoulli.support` and `TransformedDistribution.support` must both be descriptors
ERROR Class member `RelaxedBernoulli.base_dist` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/relaxed_bernoulli.py:143:5
|
143 | base_dist: LogitRelaxedBernoulli
| ^^^^^^^^^
|
`RelaxedBernoulli.base_dist` has type `LogitRelaxedBernoulli`, which is not consistent with `Distribution | Independent[Distribution | Unknown] | Unknown` in `TransformedDistribution.base_dist` (the type of read-write attributes cannot be changed)
ERROR Class member `ExpRelaxedCategorical.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/relaxed_categorical.py:41:5
|
41 | arg_constraints = {"probs": constraints.simplex, "logits": constraints.real_vector}
| ^^^^^^^^^^^^^^^
|
`ExpRelaxedCategorical.arg_constraints` has type `dict[str, _IndependentConstraint | _Simplex]`, which is not assignable to `BoundMethod[ExpRelaxedCategorical, (self: ExpRelaxedCategorical) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Class member `RelaxedOneHotCategorical.support` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/relaxed_categorical.py:130:5
|
130 | support = constraints.simplex
| ^^^^^^^
|
`RelaxedOneHotCategorical.support` and `TransformedDistribution.support` must both be descriptors
ERROR Class member `RelaxedOneHotCategorical.base_dist` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/relaxed_categorical.py:132:5
|
132 | base_dist: ExpRelaxedCategorical
| ^^^^^^^^^
|
`RelaxedOneHotCategorical.base_dist` has type `ExpRelaxedCategorical`, which is not consistent with `Distribution | Independent[Distribution | Unknown] | Unknown` in `TransformedDistribution.base_dist` (the type of read-write attributes cannot be changed)
ERROR Class member `StudentT.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/studentT.py:34:5
|
34 | arg_constraints = {
| ^^^^^^^^^^^^^^^
|
`StudentT.arg_constraints` has type `dict[str, _GreaterThan | _Real]`, which is not assignable to `BoundMethod[StudentT, (self: StudentT) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR Class member `TransformedDistribution.support` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/transformed_distribution.py:126:9
|
126 | def support(self):
| ^^^^^^^
|
`TransformedDistribution.support` and `Distribution.support` must both be descriptors
ERROR Class member `_InverseTransform.domain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:229:9
|
229 | def domain(self):
| ^^^^^^
|
`_InverseTransform.domain` and `Transform.domain` must both be descriptors
ERROR Class member `_InverseTransform.codomain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:234:9
|
234 | def codomain(self):
| ^^^^^^^^
|
`_InverseTransform.codomain` and `Transform.codomain` must both be descriptors
ERROR Class member `ComposeTransform.domain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:303:9
|
303 | def domain(self):
| ^^^^^^
|
`ComposeTransform.domain` and `Transform.domain` must both be descriptors
ERROR Class member `ComposeTransform.codomain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:318:9
|
318 | def codomain(self):
| ^^^^^^^^
|
`ComposeTransform.codomain` and `Transform.codomain` must both be descriptors
ERROR Class member `IndependentTransform.domain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:437:9
|
437 | def domain(self):
| ^^^^^^
|
`IndependentTransform.domain` and `Transform.domain` must both be descriptors
ERROR Class member `IndependentTransform.codomain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:443:9
|
443 | def codomain(self):
| ^^^^^^^^
|
`IndependentTransform.codomain` and `Transform.codomain` must both be descriptors
ERROR Class member `ReshapeTransform.domain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:510:9
|
510 | def domain(self):
| ^^^^^^
|
`ReshapeTransform.domain` and `Transform.domain` must both be descriptors
ERROR Class member `ReshapeTransform.codomain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:514:9
|
514 | def codomain(self):
| ^^^^^^^^
|
`ReshapeTransform.codomain` and `Transform.codomain` must both be descriptors
ERROR Class member `AffineTransform.domain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:767:9
|
767 | def domain(self):
| ^^^^^^
|
`AffineTransform.domain` and `Transform.domain` must both be descriptors
ERROR Class member `AffineTransform.codomain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:773:9
|
773 | def codomain(self):
| ^^^^^^^^
|
`AffineTransform.codomain` and `Transform.codomain` must both be descriptors
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/transforms.py:870:13
|
870 | z = r**2
| ^^^^
|
Argument `Literal[2]` is not assignable to parameter with type `TensorBase`
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/transforms.py:870:13
|
870 | z = r**2
| ^^^^
|
Expected 1 more positional argument
ERROR Class member `CatTransform.domain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:1158:9
|
1158 | def domain(self):
| ^^^^^^
|
`CatTransform.domain` and `Transform.domain` must both be descriptors
ERROR Class member `CatTransform.codomain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:1164:9
|
1164 | def codomain(self):
| ^^^^^^^^
|
`CatTransform.codomain` and `Transform.codomain` must both be descriptors
ERROR Class member `StackTransform.domain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:1236:9
|
1236 | def domain(self):
| ^^^^^^
|
`StackTransform.domain` and `Transform.domain` must both be descriptors
ERROR Class member `StackTransform.codomain` overrides parent class `Transform` in an inconsistent manner [bad-override]
--> torch/distributions/transforms.py:1240:9
|
1240 | def codomain(self):
| ^^^^^^^^
|
`StackTransform.codomain` and `Transform.codomain` must both be descriptors
ERROR Class member `Uniform.support` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/uniform.py:82:9
|
82 | def support(self):
| ^^^^^^^
|
`Uniform.support` and `Distribution.support` must both be descriptors
ERROR `Tensor | UnionType` is not assignable to `Tensor` (caused by inconsistent types when breaking cycles) [bad-assignment]
--> torch/distributions/von_mises.py:95:5
|
95 | / while not done.all():
96 | | u = torch.rand((3,) + x.shape, dtype=loc.dtype, device=loc.device)
97 | | u1, u2, u3 = u.unbind()
98 | | z = torch.cos(math.pi * u1)
99 | | f = (1 + proposal_r * z) / (proposal_r + z)
100 | | c = concentration * (proposal_r - f)
| |_____________________________________________^
|
ERROR No matching overload found for function `torch._C._VariableFunctions.where` [no-matching-overload]
--> torch/distributions/von_mises.py:103:28
|
103 | x = torch.where(accept, (u3 - 0.5).sign() * f.acos(), x)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(condition: Tensor) -> tuple[Tensor, ...]
(condition: Tensor, input: Tensor, other: Tensor, *, out: Tensor | None = None) -> Tensor [closest match]
(condition: Tensor, self: bool | complex | float | int, other: Tensor) -> Tensor
(condition: Tensor, input: Tensor, other: bool | complex | float | int) -> Tensor
(condition: Tensor, self: bool | complex | float | int, other: bool | complex | float | int) -> Tensor
ERROR Class member `VonMises.arg_constraints` overrides parent class `Distribution` in an inconsistent manner [bad-override]
--> torch/distributions/von_mises.py:126:5
|
126 | arg_constraints = {"loc": constraints.real, "concentration": constraints.positive}
| ^^^^^^^^^^^^^^^
|
`VonMises.arg_constraints` has type `dict[str, _GreaterThan | _Real]`, which is not assignable to `BoundMethod[VonMises, (self: VonMises) -> dict[str, Constraint]]`, the property getter for `Distribution.arg_constraints`
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/von_mises.py:163:28
|
163 | tau = 1 + (1 + 4 * kappa**2).sqrt()
| ^^^^^^^^
|
Argument `Literal[2]` is not assignable to parameter with type `TensorBase`
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/von_mises.py:163:28
|
163 | tau = 1 + (1 + 4 * kappa**2).sqrt()
| ^^^^^^^^
|
Expected 1 more positional argument
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/von_mises.py:165:28
|
165 | _proposal_r = (1 + rho**2) / (2 * rho)
| ^^^^^^
|
Argument `Literal[2]` is not assignable to parameter with type `TensorBase`
ERROR `**` is not supported between `Tensor` and `Literal[2]` [unsupported-operation]
--> torch/distributions/von_mises.py:165:28
|
165 | _proposal_r = (1 + rho**2) / (2 * rho)
| ^^^^^^
|
Expected 1 more positional argument
ERROR Class member `Weibull.support` overrides parent class `TransformedDistribution` in an inconsistent manner [bad-override]
--> torch/distributions/weibull.py:38:5
|
38 | support = constraints.positive
| ^^^^^^^
|
`Weibull.support` and `TransformedDistribution.support` must both be descriptors
ERROR Argument `list[AffineTransform | PowerTransform]` is not assignable to parameter `transforms` with type `Transform | list[Transform]` in function `torch.distributions.transformed_distribution.TransformedDistribution.__init__` [bad-argument-type]
--> torch/distributions/weibull.py:55:37
|
55 | super().__init__(base_dist, transforms, validate_args=validate_args)
| ^^^^^^^^^^
|
ERROR Attribute `scale_tril` of class `Wishart` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/wishart.py:119:13
|
119 | self.scale_tril = param.expand(batch_shape + (-1, -1))
| ^^^^^^^^^^^^^^^
|
ERROR Attribute `covariance_matrix` of class `Wishart` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/wishart.py:121:13
|
121 | self.covariance_matrix = param.expand(batch_shape + (-1, -1))
| ^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Attribute `precision_matrix` of class `Wishart` is a read-only descriptor with no `__set__` and cannot be set [read-only]
--> torch/distributions/wishart.py:123:13
|
123 | self.precision_matrix = param.expand(batch_shape + (-1, -1))
| ^^^^^^^^^^^^^^^^^^^^^
|
ERROR Class member `Wishart._log_normalizer` overrides parent class `ExponentialFamily` in an inconsistent manner [bad-override]
--> torch/distributions/wishart.py:338:9
|
338 | def _log_normalizer(self, x, y):
| ^^^^^^^^^^^^^^^
|
`Wishart._log_normalizer` has type `BoundMethod[Wishart, (self: Wishart, x: Unknown, y: Unknown) -> Unknown]`, which is not assignable to `BoundMethod[Wishart, (self: Wishart, *natural_params: Unknown) -> Unknown]`, the type of `ExponentialFamily._log_normalizer`
ERROR Class member `GraphPickler.reducer_override` overrides parent class `Pickler` in an inconsistent manner [bad-override]
--> torch/fx/_graph_pickler.py:68:9
|
68 | def reducer_override(
| ^^^^^^^^^^^^^^^^
|
`GraphPickler.reducer_override` has type `BoundMethod[GraphPickler, (self: GraphPickler, obj: object) -> tuple[(...) -> Any, tuple[Any, ...]]]`, which is not consistent with `(Any) -> Any` in `Pickler.reducer_override` (the type of read-write attributes cannot be changed)
ERROR Returned type `tuple[(self: _SymNodePickleData, unpickle_state: _UnpickleState) -> SymInt, tuple[_SymNodePickleData, _UnpickleStateToken]]` is not assignable to declared return type `tuple[(Self@_SymNodePickleData, _UnpickleState) -> _SymNodeT, tuple[Self@_SymNodePickleData, _UnpickleStateToken]]` [bad-return]
--> torch/fx/_graph_pickler.py:204:20
|
204 | return _SymNodePickleData.unpickle_sym_int, args
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `device | str` is not assignable to parameter `device` with type `device` in function `torch._subclasses.fake_tensor.FakeTensor.__new__` [bad-argument-type]
--> torch/fx/_graph_pickler.py:280:21
|
280 | device,
| ^^^^^^
|
ERROR Cannot set item in `dict[str, (node: Unknown) -> ParameterProxy]` [unsupported-operation]
--> torch/fx/_symbolic_trace.py:606:33
|
606 | / ... None
607 | | ... if not self.param_shapes_constant
608 | | ... else lambda node: ParameterProxy(
609 | | ... self, node, n, attr_val
610 | | ... )
| |_______________________^
|
Argument `((node: Unknown) -> ParameterProxy) | None` is not assignable to parameter `value` with type `(node: Unknown) -> ParameterProxy` in function `dict.__setitem__`
ERROR Argument `Iterable[Unknown]` is not assignable to parameter `partitions` with type `list[Partition]` in function `find_partition_to_combine_based_on_size` [bad-argument-type]
--> torch/fx/experimental/accelerator_partitioner.py:660:61
|
660 | sorted_partitions, available_mem_bytes, partitions
| ^^^^^^^^^^
|
ERROR Object of class `Partition` has no attribute `left_mem_bytes` [missing-attribute]
--> torch/fx/experimental/accelerator_partitioner.py:705:17
|
705 | partition.left_mem_bytes = available_mem_bytes
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR `list[Node | None]` is not assignable to variable `node_pair` with type `list[Node]` [bad-assignment]
--> torch/fx/experimental/accelerator_partitioner.py:1000:33
|
1000 | node_pair = [node, n1]
| ^^^^^^^^^^
|
ERROR Argument `Proxy | Tensor` is not assignable to parameter `tensor` with type `Tensor` in function `torch.functional.split` [bad-argument-type]
--> torch/fx/experimental/merge_matmul.py:33:24
|
33 | return torch.split(result, splits)
| ^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `proxy_factory_fn` with type `(Node) -> Proxy` in function `torch.fx.proxy.TracerBase.create_proxy` [bad-argument-type]
--> torch/fx/experimental/meta_tracer.py:174:58
|
174 | kind, target, args, kwargs, name, type_expr, proxy_factory_fn
| ^^^^^^^^^^^^^^^^
|
ERROR Expected a callable, got `None` [not-callable]
--> torch/fx/experimental/meta_tracer.py:196:28
|
196 | meta_out = meta_target(*args_metas, **kwargs_metas)
| ^^^^^^^^^^^
|
ERROR Argument `BinConstraintD` is not assignable to parameter `object` with type `BinConstraintT | CanReshape` in function `list.append` [bad-argument-type]
--> torch/fx/experimental/migrate_gradual_types/constraint_generator.py:531:36
|
531 | num_constraints.append(BinConstraintD(var, Dyn, op_neq))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `BinConstraintD` is not assignable to parameter `object` with type `BinConstraintT | CanReshape` in function `list.append` [bad-argument-type]
--> torch/fx/experimental/migrate_gradual_types/constraint_generator.py:534:36
|
534 | num_constraints.append(BinConstraintD(t, Dyn, op_neq))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `nodes` [missing-attribute]
--> torch/fx/experimental/migrate_gradual_types/constraint_generator.py:1478:18
|
1478 | for n in graph.nodes:
| ^^^^^^^^^^^
|
ERROR Cannot index into `dict[type[BatchNorm2d] | type[Conv2d] | type[Linear], ((a: Unknown, _: Unknown) -> MkldnnBatchNorm) | type[MkldnnConv2d] | type[MkldnnLinear]]` [index-error]
--> torch/fx/experimental/optimization.py:196:41
|
196 | new_module = mkldnn_map[type(cur_module)](cur_module, torch.float)
| ^^^^^^^^^^^^^^^^
|
Argument `type[Module]` is not assignable to parameter `key` with type `type[BatchNorm2d] | type[Conv2d] | type[Linear]` in function `dict.__getitem__`
ERROR Argument `Unknown | None` is not assignable to parameter `old_modules` with type `dict[Module, Module]` in function `reset_modules` [bad-argument-type]
--> torch/fx/experimental/optimization.py:266:69
|
266 | submodule.graph.nodes, dict(submodule.named_modules()), old_modules
| ^^^^^^^^^^^
|
ERROR Argument `(xs: Any) -> tuple[list[tuple[SequenceKey[@_], Unknown]], None]` is not assignable to parameter `flatten_with_keys_fn` with type `((Any) -> tuple[list[tuple[KeyEntry, Any]], Any]) | None` in function `torch.utils._pytree.register_pytree_node` [bad-argument-type]
--> torch/fx/experimental/proxy_tensor.py:127:26
|
127 | flatten_with_keys_fn=lambda xs: (
| __________________________^
128 | | [(pytree.SequenceKey(i), x) for i, x in enumerate(xs)],
129 | | None,
130 | | ),
| |_____^
|
ERROR No matching overload found for function `get_proxy_slot` [no-matching-overload]
--> torch/fx/experimental/proxy_tensor.py:309:31
|
309 | return bool(get_proxy_slot(obj, tracer, False, lambda _: True))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(obj: Tensor, tracer: PythonKeyTracer | _GraphAppendingTracerEx) -> _ProxyTensor
(obj: Tensor, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: U) -> _ProxyTensor | U
(obj: Tensor, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: U, transform: (_ProxyTensor) -> R) -> R | U [closest match]
(obj: FakeScriptObject | ScriptObject, tracer: PythonKeyTracer | _GraphAppendingTracerEx) -> Proxy
(obj: FakeScriptObject | ScriptObject, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: U) -> Proxy | U
(obj: FakeScriptObject | ScriptObject, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: U, transform: (Proxy) -> R) -> R | U
(obj: SymBool | SymFloat | SymInt, tracer: PythonKeyTracer | _GraphAppendingTracerEx) -> Thunk[Proxy]
(obj: SymBool | SymFloat | SymInt, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: T) -> Thunk[Proxy] | T
(obj: SymBool | SymFloat | SymInt, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: U, transform: (Thunk[Proxy]) -> R) -> R | U
ERROR `not in` is not supported between `FakeScriptObject` and `_SymNodeDict` [unsupported-operation]
--> torch/fx/experimental/proxy_tensor.py:405:8
|
405 | if obj not in tracker:
| ^^^
|
Argument `FakeScriptObject` is not assignable to parameter `key` with type `SymBool | SymFloat | SymInt` in function `_SymNodeDict.__contains__`
ERROR `not in` is not supported between `ScriptObject` and `_SymNodeDict` [unsupported-operation]
--> torch/fx/experimental/proxy_tensor.py:405:8
|
405 | if obj not in tracker:
| ^^^
|
Argument `ScriptObject` is not assignable to parameter `key` with type `SymBool | SymFloat | SymInt` in function `_SymNodeDict.__contains__`
ERROR `not in` is not supported between `Tensor` and `_SymNodeDict` [unsupported-operation]
--> torch/fx/experimental/proxy_tensor.py:405:8
|
405 | if obj not in tracker:
| ^^^
|
Argument `Tensor` is not assignable to parameter `key` with type `SymBool | SymFloat | SymInt` in function `_SymNodeDict.__contains__`
ERROR Cannot index into `MutableMapping[FakeScriptObject | ScriptObject, Proxy]` [index-error]
--> torch/fx/experimental/proxy_tensor.py:416:25
|
416 | value = tracker[obj]
| ^^^
|
Argument `FakeScriptObject | ScriptObject | SymBool | SymFloat | SymInt | Tensor` is not assignable to parameter `key` with type `FakeScriptObject | ScriptObject` in function `typing.Mapping.__getitem__`
ERROR Cannot index into `MutableMapping[SymBool | SymFloat | SymInt, Thunk[Proxy]]` [index-error]
--> torch/fx/experimental/proxy_tensor.py:416:25
|
416 | value = tracker[obj]
| ^^^
|
Argument `FakeScriptObject | ScriptObject | SymBool | SymFloat | SymInt | Tensor` is not assignable to parameter `key` with type `SymBool | SymFloat | SymInt` in function `typing.Mapping.__getitem__`
ERROR Cannot index into `MutableMapping[Tensor, _ProxyTensor]` [index-error]
--> torch/fx/experimental/proxy_tensor.py:416:25
|
416 | value = tracker[obj]
| ^^^
|
Argument `FakeScriptObject | ScriptObject | SymBool | SymFloat | SymInt | Tensor` is not assignable to parameter `key` with type `Tensor` in function `typing.Mapping.__getitem__`
ERROR Cannot index into `_SymNodeDict` [index-error]
--> torch/fx/experimental/proxy_tensor.py:416:25
|
416 | value = tracker[obj]
| ^^^
|
Argument `FakeScriptObject | ScriptObject | SymBool | SymFloat | SymInt | Tensor` is not assignable to parameter `key` with type `SymBool | SymFloat | SymInt` in function `_SymNodeDict.__getitem__`
ERROR No matching overload found for function `get_proxy_slot` [no-matching-overload]
--> torch/fx/experimental/proxy_tensor.py:791:26
|
791 | return get_proxy_slot(t, tracer, t)
| ^^^^^^^^^^^^^^
|
Possible overloads:
(obj: Tensor, tracer: PythonKeyTracer | _GraphAppendingTracerEx) -> _ProxyTensor
(obj: Tensor, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: U) -> _ProxyTensor | U [closest match]
(obj: Tensor, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: U, transform: (_ProxyTensor) -> R) -> R | U
(obj: FakeScriptObject | ScriptObject, tracer: PythonKeyTracer | _GraphAppendingTracerEx) -> Proxy
(obj: FakeScriptObject | ScriptObject, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: U) -> Proxy | U
(obj: FakeScriptObject | ScriptObject, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: U, transform: (Proxy) -> R) -> R | U
(obj: SymBool | SymFloat | SymInt, tracer: PythonKeyTracer | _GraphAppendingTracerEx) -> Thunk[Proxy]
(obj: SymBool | SymFloat | SymInt, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: T) -> Thunk[Proxy] | T
(obj: SymBool | SymFloat | SymInt, tracer: PythonKeyTracer | _GraphAppendingTracerEx, default: U, transform: (Thunk[Proxy]) -> R) -> R | U
ERROR No matching overload found for function `fetch_object_proxy` [no-matching-overload]
--> torch/fx/experimental/proxy_tensor.py:839:31
|
839 | fetch_object_proxy(tracer, x)
| ^^^^^^^^^^^
|
Possible overloads:
(tracer: PythonKeyTracer | _GraphAppendingTracerEx, t: Tensor) -> Tensor | _ProxyTensor [closest match]
(tracer: PythonKeyTracer | _GraphAppendingTracerEx, t: FakeScriptObject | ScriptObject) -> FakeScriptObject | Proxy | ScriptObject
(tracer: PythonKeyTracer | _GraphAppendingTracerEx, t: SymBool | SymFloat | SymInt) -> SymBool | SymFloat | SymInt | Thunk[Proxy]
ERROR `OpOverload[Ellipsis, Any]` is not assignable to attribute `torch_fn_metadata` with type `None` [bad-assignment]
--> torch/fx/experimental/proxy_tensor.py:1413:41
|
1413 | self.tracer.torch_fn_metadata = func
| ^^^^
|
ERROR Argument `Node | object` is not assignable to parameter `enabled` with type `bool` in function `torch._C._set_grad_enabled` [bad-argument-type]
--> torch/fx/experimental/proxy_tensor.py:1462:22
|
1462 | func(*args, **kwargs)
| ^^^^^
|
ERROR Class member `DecompositionInterpreter.placeholder` overrides parent class `Interpreter` in an inconsistent manner [bad-override]
--> torch/fx/experimental/proxy_tensor.py:1675:9
|
1675 | def placeholder(
| ^^^^^^^^^^^
|
`DecompositionInterpreter.placeholder` has type `BoundMethod[DecompositionInterpreter, (self: DecompositionInterpreter, target: str, args: tuple[object, ...], kwargs: dict[str, object]) -> object]`, which is not assignable to `BoundMethod[DecompositionInterpreter, (self: DecompositionInterpreter, target: ((...) -> Any) | str, args: tuple[Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None, ...], kwargs: dict[str, Any]) -> Any]`, the type of `Interpreter.placeholder`
ERROR Class member `DecompositionInterpreter.get_attr` overrides parent class `Interpreter` in an inconsistent manner [bad-override]
--> torch/fx/experimental/proxy_tensor.py:1687:9
|
1687 | def get_attr(
| ^^^^^^^^
|
`DecompositionInterpreter.get_attr` has type `BoundMethod[DecompositionInterpreter, (self: DecompositionInterpreter, target: str, args: tuple[object, ...], kwargs: dict[str, object]) -> object]`, which is not assignable to `BoundMethod[DecompositionInterpreter, (self: DecompositionInterpreter, target: ((...) -> Any) | str, args: tuple[Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None, ...], kwargs: dict[str, Any]) -> Any]`, the type of `Interpreter.get_attr`
ERROR Class member `DecompositionInterpreter.output` overrides parent class `Interpreter` in an inconsistent manner [bad-override]
--> torch/fx/experimental/proxy_tensor.py:1700:9
|
1700 | def output(
| ^^^^^^
|
`DecompositionInterpreter.output` has type `BoundMethod[DecompositionInterpreter, (self: DecompositionInterpreter, target: str, args: tuple[object, ...], kwargs: dict[str, object]) -> object]`, which is not assignable to `BoundMethod[DecompositionInterpreter, (self: DecompositionInterpreter, target: ((...) -> Any) | str, args: tuple[Mapping[str, Unknown] | Node | OpOverload[Ellipsis, Any] | Sequence[Unknown] | SymBool | SymFloat | SymInt | Tensor | bool | complex | device | dtype | float | int | layout | memory_format | range | slice[Any, Any, Any] | str | tuple[Unknown, ...] | None, ...], kwargs: dict[str, Any]) -> Any]`, the type of `Interpreter.output`
ERROR `in` is not supported between `Unknown` and `None` [unsupported-operation]
--> torch/fx/experimental/proxy_tensor.py:1785:16
|
1785 | if m in self.submodule_paths:
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR `None` is not subscriptable [unsupported-operation]
--> torch/fx/experimental/proxy_tensor.py:1788:21
|
1788 | self.submodule_paths[m],
| ^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Cannot set item in `None` [unsupported-operation]
--> torch/fx/experimental/proxy_tensor.py:1793:17
|
1793 | self.submodule_paths[m] = name
| ^^^^^^^^^^^^^^^^^^^^^^^
|
Object of class `NoneType` has no attribute `__setitem__`
ERROR No matching overload found for function `type.__new__` [no-matching-overload]
--> torch/fx/experimental/proxy_tensor.py:1818:38
|
1818 | self.__class__ = type(
| ______________________________________^
1819 | | base.__class__.__name__,
1820 | | (self.__class__, base.__class__),
1821 | | {},
1822 | | )
| |_________________^
|
Possible overloads:
(cls: type[type], o: object, /) -> type [closest match]
(cls: type[Self], name: str, bases: tuple[type, ...], namespace: dict[str, Any], /, **kwds: Any) -> Self
ERROR Cannot index into `WeakKeyDictionary[_AttrProxy, str]` [index-error]
--> torch/fx/experimental/proxy_tensor.py:1840:63
|
1840 | return AttrProxy(attr_val, tracer.proxy_paths[self] + "." + name)
| ^^^^
|
Argument `Module` is not assignable to parameter `key` with type `_AttrProxy` in function `weakref.WeakKeyDictionary.__getitem__`
ERROR Cannot index into `WeakKeyDictionary[_AttrProxy, str]` [index-error]
--> torch/fx/experimental/proxy_tensor.py:1852:69
|
1852 | return AttrProxy(res, f"{tracer.proxy_paths[self]}.{idx}")
| ^^^^
|
Argument `Sequential` is not assignable to parameter `key` with type `_AttrProxy` in function `weakref.WeakKeyDictionary.__getitem__`
ERROR Cannot index into `WeakKeyDictionary[_AttrProxy, str]` [index-error]
--> torch/fx/experimental/proxy_tensor.py:1856:69
|
1856 | return AttrProxy(res, f"{tracer.proxy_paths[self]}.{idx}")
| ^^^^
|
Argument `ModuleList` is not assignable to parameter `key` with type `_AttrProxy` in function `weakref.WeakKeyDictionary.__getitem__`
ERROR Argument `SupportsIndex` is not assignable to parameter `factor` with type `int` in function `div_by_factor` [bad-argument-type]
--> torch/fx/experimental/symbolic_shapes.py:843:35
|
843 | atoms = [div_by_factor(x, factor) for x in atoms]
| ^^^^^^
|
ERROR Cannot set item in `dict[Unknown, tuple[KeyEntry, ...]]` [unsupported-operation]
--> torch/fx/experimental/symbolic_shapes.py:1238:23
|
1238 | r[unbacked] = path + (DivideByKey(divisor),)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Argument `tuple[*tuple[KeyEntry, ...], DivideByKey]` is not assignable to parameter `value` with type `tuple[KeyEntry, ...]` in function `dict.__setitem__`
ERROR Cannot set item in `dict[Unknown, tuple[KeyEntry, ...]]` [unsupported-operation]
--> torch/fx/experimental/symbolic_shapes.py:1260:20
|
1260 | r[s.lhs] = path + (ConvertIntKey(),)
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
Argument `tuple[*tuple[KeyEntry, ...], ConvertIntKey]` is not assignable to parameter `value` with type `tuple[KeyEntry, ...]` in function `dict.__setitem__`
ERROR `dict[@_, @_]` is not assignable to attribute `inner_contexts` with type `Never` [bad-assignment]
--> torch/fx/experimental/symbolic_shapes.py:2176:35
|
2176 | self.inner_contexts = {}
| ^^
|
ERROR Object of class `object` has no attribute `args` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2264:55
|
2264 | if any(arg is not new_arg for arg, new_arg in zip(expr.args, new_args)):
| ^^^^^^^^^
|
ERROR Object of class `object` has no attribute `func` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2265:29
|
2265 | return _fast_expand(expr.func(*new_args))
| ^^^^^^^^^
|
ERROR Object of class `object` has no attribute `is_Pow` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2267:8
|
2267 | if expr.is_Pow:
| ^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `is_Mul` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2276:10
|
2276 | elif expr.is_Mul:
| ^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `args` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2279:20
|
2279 | for arg in expr.args:
| ^^^^^^^^^
|
ERROR Object of class `object` has no attribute `xreplace` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2400:20
|
2400 | new_expr = expr.xreplace(new_shape_env)
| ^^^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `has` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2937:12
|
2937 | if expr.has(Mod):
| ^^^^^^^^
|
ERROR Object of class `object` has no attribute `replace` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2938:20
|
2938 | expr = expr.replace(Mod, mod_handler)
| ^^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `has` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2941:12
|
2941 | if expr.has(PythonMod):
| ^^^^^^^^
|
ERROR Object of class `object` has no attribute `replace` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2942:20
|
2942 | expr = expr.replace(PythonMod, mod_handler)
| ^^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `has` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2943:12
|
2943 | if expr.has(FloorDiv):
| ^^^^^^^^
|
ERROR Object of class `object` has no attribute `replace` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:2944:20
|
2944 | expr = expr.replace(FloorDiv, floor_div_handler)
| ^^^^^^^^^^^^
|
ERROR Cannot set item in `dict[int, Unknown]` [unsupported-operation]
--> torch/fx/experimental/symbolic_shapes.py:5061:33
|
5061 | self.val_to_var[val] = sympy_expr
| ^^^
|
Argument `SymInt | float | int` is not assignable to parameter `key` with type `int` in function `dict.__setitem__`
ERROR `list[StatelessSymbolicContext[Ellipsis, Unknown] | None]` is not assignable to variable `input_contexts` with type `list[SymbolicContext] | None` [bad-assignment]
--> torch/fx/experimental/symbolic_shapes.py:5292:30
|
5292 | input_contexts = [
| ______________________________^
5293 | | _create_no_constraints_context(t) if isinstance(t, Tensorlike) else None
5294 | | for t in placeholders
5295 | | ]
| |_____________^
|
ERROR Argument `FakeTensor | FakeTensorMeta` is not assignable to parameter `t` with type `Tensor` in function `_create_no_constraints_context` [bad-argument-type]
--> torch/fx/experimental/symbolic_shapes.py:5293:48
|
5293 | _create_no_constraints_context(t) if isinstance(t, Tensorlike) else None
| ^
|
ERROR `FakeTensor | FakeTensorMeta` is not assignable to `FakeTensor` (caused by inconsistent types when breaking cycles) [bad-assignment]
--> torch/fx/experimental/symbolic_shapes.py:5298:13
|
5298 | / for i, (t, context) in enumerate(zip(placeholders, input_contexts)):
5299 | | if isinstance(t, Tensorlike):
5300 | | if context is None:
5301 | | input_contexts[i] = _create_no_constraints_context(t)
5302 | | else:
5303 | | assert isinstance(t, (SymInt, int, SymFloat, float))
| |_________________________________________________________________________^
|
ERROR Argument `FakeTensor | FakeTensorMeta` is not assignable to parameter `t` with type `Tensor` in function `_create_no_constraints_context` [bad-argument-type]
--> torch/fx/experimental/symbolic_shapes.py:5301:76
|
5301 | input_contexts[i] = _create_no_constraints_context(t)
| ^
|
ERROR No matching overload found for function `zip.__new__` [no-matching-overload]
--> torch/fx/experimental/symbolic_shapes.py:5586:38
|
5586 | for t, source, context in zip(placeholders, sources, input_contexts):
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(cls: type[zip[_T_co]], *, strict: bool = ...) -> zip[Any] [closest match]
(cls: type[zip[_T_co]], iter1: Iterable[_T1], /, *, strict: bool = ...) -> zip[tuple[_T1]]
(cls: type[zip[_T_co]], iter1: Iterable[_T1], iter2: Iterable[_T2], /, *, strict: bool = ...) -> zip[tuple[_T1, _T2]]
(cls: type[zip[_T_co]], iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /, *, strict: bool = ...) -> zip[tuple[_T1, _T2, _T3]]
(cls: type[zip[_T_co]], iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /, *, strict: bool = ...) -> zip[tuple[_T1, _T2, _T3, _T4]]
(cls: type[zip[_T_co]], iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], /, *, strict: bool = ...) -> zip[tuple[_T1, _T2, _T3, _T4, _T5]]
(cls: type[zip[_T_co]], iter1: Iterable[Any], iter2: Iterable[Any], iter3: Iterable[Any], iter4: Iterable[Any], iter5: Iterable[Any], iter6: Iterable[Any], /, *iterables: Iterable[Any], *, strict: bool = ...) -> zip[tuple[Any, ...]]
ERROR Object of class `object` has no attribute `size` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:5645:44
|
5645 | for i, ss in enumerate(curr_t.size()):
| ^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `stride` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:5650:44
|
5650 | for i, ss in enumerate(curr_t.stride()):
| ^^^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `storage_offset` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:5657:25
|
5657 | curr_t.storage_offset(),
| ^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `add_equality` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:5702:21
|
5702 | self.dim_constraints.add_equality(source, expr)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `add` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:5855:13
|
5855 | self.dim_constraints.add(expr)
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `add` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:5871:21
|
5871 | self.dim_constraints.add(sympy.Ge(symbol, r.lower))
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `add` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:5879:21
|
5879 | self.dim_constraints.add(sympy.Le(symbol, r.upper))
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `str` is not assignable to parameter `element` with type `LiteralString` in function `set.add` [bad-argument-type]
--> torch/fx/experimental/symbolic_shapes.py:5947:37
|
5947 | debug_names.add(debug_name)
| ^^^^^^^^^^
|
ERROR `set[Unknown]` is not assignable to variable `symints` with type `Sequence[SymInt]` [bad-assignment]
--> torch/fx/experimental/symbolic_shapes.py:6080:19
|
6080 | symints = {
| ___________________^
6081 | | s.node.expr for s in symints if isinstance(s.node.expr, sympy.Symbol)
6082 | | }
| |_________^
|
ERROR `FakeTensor | SymInt` is not assignable to `FakeTensor` (caused by inconsistent types when breaking cycles) [bad-assignment]
--> torch/fx/experimental/symbolic_shapes.py:6125:9
|
6125 | / for t, arg in zip(placeholders, args):
6126 | | if t is None:
6127 | | continue
6128 | | if isinstance(t, SymInt):
6129 | | bind_symint(arg, t)
6130 | | continue
| |_________________________^
|
ERROR Object of class `object` has no attribute `free_symbols` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:6342:18
|
6342 | for s in expr.free_symbols:
| ^^^^^^^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `xreplace` [missing-attribute]
--> torch/fx/experimental/symbolic_shapes.py:6351:32
|
6351 | return safe_expand(expr.xreplace(replacements))
| ^^^^^^^^^^^^^
|
ERROR `int | None` is not assignable to `None` (caused by inconsistent types when breaking cycles) [bad-assignment]
--> torch/fx/experimental/symbolic_shapes.py:7142:9
|
7142 | / for i, instr in enumerate(instructions):
7143 | | if instr.starts_line is not None:
7144 | | cur = instr.starts_line
7145 | | if cur != frame.f_lineno:
7146 | | continue
7147 | | if start is None:
| |______________________________^
|
ERROR `SymInt | int` is not assignable to `int` (caused by inconsistent types when breaking cycles) [bad-assignment]
--> torch/fx/experimental/symbolic_shapes.py:8045:21
|
8045 | / for i, dim in enumerate(leaf.shape):
8046 | | if isinstance(dim, torch.SymInt):
8047 | | src_map[str(dim.node.expr)].append(f"{name}.shape[{i}]")
| |____________________________________________________________________________________^
|
WARN `halt_ordering` is deprecated [deprecated]
--> torch/fx/experimental/unification/multipledispatch/__init__.py:4:5
|
4 | halt_ordering,
| -------------
|
WARN `restart_ordering` is deprecated [deprecated]
--> torch/fx/experimental/unification/multipledispatch/__init__.py:6:5
|
6 | restart_ordering,
| ----------------
|
ERROR Expected 0 type arguments for `Variadic`, got 1 [bad-specialization]
--> torch/fx/experimental/unification/multipledispatch/dispatcher.py:241:38
|
241 | new_signature.append(Variadic[typ[0]])
| ^^^^^^^^^^^^^^^^
|
ERROR Type `SupportsNext[Unknown]` is not iterable [not-iterable]
--> torch/fx/experimental/unification/unification_tools.py:301:16
|
301 | for key in ks:
| ^^
|
ERROR Object of class `FunctionType` has no attribute `split` [missing-attribute]
--> torch/fx/graph.py:1839:36
|
1839 | target_atoms = node.target.split(".")
| ^^^^^^^^^^^^^^^^^
|
ERROR `type[Tracer]` is not assignable to attribute `_tracer_cls` with type `None` [bad-assignment]
--> torch/fx/graph_module.py:536:32
|
536 | self._tracer_cls = self.graph._tracer_cls
| ^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Type variable bounds and constraints must be concrete [invalid-annotation]
--> torch/fx/node.py:62:40
|
62 | ArgumentT = TypeVar("ArgumentT", bound=Argument)
| ^^^^^^^^
|
ERROR `Iterable[Unknown] | list[Parameter]` is not assignable to `list[Parameter]` (caused by inconsistent types when breaking cycles) [bad-assignment]
--> torch/fx/operator_schemas.py:123:13
|
123 | / for idx, p in enumerate(parameters):
124 | | assert p.kind == Parameter.POSITIONAL_OR_KEYWORD
125 | | parameters[idx] = Parameter(
126 | | name=p.name,
127 | | kind=Parameter.POSITIONAL_ONLY,
128 | | default=p.default,
| |_______________________________________^
|
ERROR Object of class `Iterable` has no attribute `append` [missing-attribute]
--> torch/fx/operator_schemas.py:131:9
|
131 | parameters.append(
| ^^^^^^^^^^^^^^^^^
|
ERROR Argument `Iterable[Unknown] | list[Parameter]` is not assignable to parameter `parameters` with type `Sequence[Parameter] | None` in function `inspect.Signature.__init__` [bad-argument-type]
--> torch/fx/operator_schemas.py:144:30
|
144 | return inspect.Signature(parameters, return_annotation=return_type)
| ^^^^^^^^^^
|
ERROR `c` may be uninitialized [unbound-name]
--> torch/fx/passes/_tensorify_python_scalars.py:167:56
|
167 | torch.ops.aten.scalar_tensor.default, (c,), {"dtype": dtype}
| ^
|
ERROR `c` may be uninitialized [unbound-name]
--> torch/fx/passes/_tensorify_python_scalars.py:170:73
|
170 | node.meta["val"] = torch.ops.aten.scalar_tensor.default(c, dtype=dtype)
| ^
|
ERROR Argument `Unknown | None` is not assignable to parameter `node` with type `Node` in function `torch.fx.passes.runtime_assert._get_sym_val` [bad-argument-type]
--> torch/fx/passes/_tensorify_python_scalars.py:222:44
|
222 | elif (sym_expr := _get_sym_val(node)) is not None:
| ^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `node` with type `Node` in function `torch.fx.proxy.MetaProxy.__init__` [bad-argument-type]
--> torch/fx/passes/_tensorify_python_scalars.py:227:25
|
227 | node, tracer=tracer, fake_mode=fake_mode
| ^^^^
|
ERROR Object of class `NoneType` has no attribute `meta` [missing-attribute]
--> torch/fx/passes/_tensorify_python_scalars.py:233:19
|
233 | val = node.meta.get("val")
| ^^^^^^^^^
|
ERROR `SymInt | int` is not assignable to `int` (caused by inconsistent types when breaking cycles) [bad-assignment]
--> torch/fx/passes/_tensorify_python_scalars.py:235:17
|
235 | / for dim in val.shape:
236 | | if isinstance(dim, torch.SymInt):
237 | | for s in dim.node.expr.free_symbols:
238 | | name = str(s)
239 | | if symbol_is_type(
240 | | s, SymT.FLOAT
| |______________________________________________^
|
ERROR Object of class `NoneType` has no attribute `op` [missing-attribute]
--> torch/fx/passes/_tensorify_python_scalars.py:251:16
|
251 | if node.op == "call_function" and (
| ^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `target` [missing-attribute]
--> torch/fx/passes/_tensorify_python_scalars.py:252:53
|
252 | replacement_op := SUPPORTED_OPS.get(node.target)
| ^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `meta` [missing-attribute]
--> torch/fx/passes/_tensorify_python_scalars.py:256:55
|
256 | compute_dtype = get_computation_dtype(node.meta["val"].dtype)
| ^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `args` [missing-attribute]
--> torch/fx/passes/_tensorify_python_scalars.py:258:26
|
258 | for a in node.args:
| ^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `meta` [missing-attribute]
--> torch/fx/passes/_tensorify_python_scalars.py:294:41
|
294 | if compute_dtype != node.meta["val"].dtype:
| ^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `replace_all_uses_with` [missing-attribute]
--> torch/fx/passes/_tensorify_python_scalars.py:302:21
|
302 | node.replace_all_uses_with(replacement_proxy.node)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `to_erase` with type `Node` in function `torch.fx.graph.Graph.erase_node` [bad-argument-type]
--> torch/fx/passes/_tensorify_python_scalars.py:303:38
|
303 | graph.erase_node(node)
| ^^^^
|
ERROR Object of class `NoneType` has no attribute `args` [missing-attribute]
--> torch/fx/passes/_tensorify_python_scalars.py:311:26
|
311 | for a in node.args:
| ^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `target` [missing-attribute]
--> torch/fx/passes/_tensorify_python_scalars.py:317:57
|
317 | failed_tensorify_ops.update(str(node.target))
| ^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `target` [missing-attribute]
--> torch/fx/passes/_tensorify_python_scalars.py:318:64
|
318 | log.info("Failed to tensorify %s", str(node.target))
| ^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `add_node` [missing-attribute]
--> torch/fx/passes/graph_drawer.py:440:17
|
440 | current_graph.add_node(dot_node)
| ^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Iterator[tuple[str, Tensor]]` is not assignable to parameter `*iterables` with type `Iterable[tuple[str, Parameter]]` in function `itertools.chain.__new__` [bad-argument-type]
--> torch/fx/passes/graph_drawer.py:444:57
|
444 | leaf_module.named_parameters(), leaf_module.named_buffers()
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Invalid expression form for base class: `namedtuple("PassResult", ["graph_module", "modified"])` [invalid-inheritance]
--> torch/fx/passes/infra/pass_base.py:14:18
|
14 | class PassResult(namedtuple("PassResult", ["graph_module", "modified"])):
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Returned type `None` is not assignable to declared return type `(...) -> Unknown` [bad-return]
--> torch/fx/passes/infra/pass_manager.py:34:16
|
34 | return None
| ^^^^
|
ERROR Expected a callable, got `object` [not-callable]
--> torch/fx/passes/infra/pass_manager.py:276:27
|
276 | res = fn(module)
| ^^
|
ERROR Object of class `NoneType` has no attribute `free_symbols` [missing-attribute]
--> torch/fx/passes/runtime_assert.py:361:35
|
361 | for symbol in sym_expr.free_symbols:
| ^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `keys` [missing-attribute]
--> torch/fx/passes/runtime_assert.py:376:32
|
376 | for key in resolved_unbacked_bindings.keys():
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR `dict[Node, list[int]]` is not assignable to variable `autocast_regions` with type `OrderedDict[Node, set[int]]` [bad-assignment]
--> torch/fx/passes/split_module.py:353:24
|
353 | autocast_regions = {k: sorted(v) for k, v in autocast_regions.items()}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR `dict[Node, list[int]]` is not assignable to variable `grad_regions` with type `OrderedDict[Node, set[int]]` [bad-assignment]
--> torch/fx/passes/split_module.py:354:20
|
354 | grad_regions = {k: sorted(v) for k, v in grad_regions.items()}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Cannot index into `set[int]` [index-error]
--> torch/fx/passes/split_module.py:418:28
|
418 | partitions[str(regions[0])].environment[node] = node
| ^^^^^^^^^^
|
Object of class `set` has no attribute `__getitem__`
ERROR Cannot index into `set[int]` [index-error]
--> torch/fx/passes/split_module.py:419:22
|
419 | for r in regions[1:]:
| ^^^^^^^^^^^
|
Object of class `set` has no attribute `__getitem__`
ERROR Cannot index into `set[int]` [index-error]
--> torch/fx/passes/split_module.py:518:22
|
518 | for r in regions[:-1]:
| ^^^^^^^^^^^^
|
Object of class `set` has no attribute `__getitem__`
ERROR Object of class `object` has no attribute `add_module` [missing-attribute]
--> torch/fx/passes/utils/common.py:67:17
|
67 | curr.add_module(name, HolderModule({}))
| ^^^^^^^^^^^^^^^
|
WARN `select_model_mode_for_export` is deprecated [deprecated]
--> torch/onnx/__init__.py:40:5
|
40 | select_model_mode_for_export,
| ----------------------------
|
ERROR Cannot index into `defaultdict[list[Unknown], list[Unknown]]` [index-error]
--> torch/onnx/_internal/exporter/_analysis.py:125:29
|
125 | target_to_nodes[str(node.target)].append(node)
| ^^^^^^^^^^^^^^^^
|
Argument `str` is not assignable to parameter `key` with type `list[Unknown]` in function `dict.__getitem__`
ERROR `tuple[float | int, Literal[0] | float]` is not assignable to variable `arg` with type `bool | float | int | list[bool] | list[float] | list[int] | str | tuple[bool] | tuple[float] | tuple[int]` [bad-assignment]
--> torch/onnx/_internal/exporter/_building.py:270:15
|
270 | arg = (arg.real, arg.imag)
| ^^^^^^^^^^^^^^^^^^^^
|
ERROR `(obj: object, class_or_tuple: UnionType | type | tuple[Unknown, ...], /) -> bool` is not assignable to attribute `isinstance` with type `(obj: Unknown, target_type: Unknown) -> Unknown` [bad-assignment]
--> torch/onnx/_internal/exporter/_capture_strategies.py:50:28
|
50 | torch.jit.isinstance = isinstance
| ^^^^^^^^^^
|
ERROR Object of class `TorchTensor` has no attribute `dtype` [missing-attribute]
--> torch/onnx/_internal/exporter/_core.py:135:12
|
135 | if self.dtype == ir.DataType.BFLOAT16:
| ^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `numpy` [missing-attribute]
--> torch/onnx/_internal/exporter/_core.py:137:68
|
137 | self.raw.view(torch.uint16).numpy(force=True).view(self.dtype.numpy())
| ^^^^^^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `numpy` [missing-attribute]
--> torch/onnx/_internal/exporter/_core.py:145:70
|
145 | return self.raw.view(torch.uint8).numpy(force=True).view(self.dtype.numpy())
| ^^^^^^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `numpy` [missing-attribute]
--> torch/onnx/_internal/exporter/_core.py:148:17
|
148 | self.dtype.numpy()
| ^^^^^^^^^^^^^^^^
|
ERROR Object of class `TorchTensor` has no attribute `name` [missing-attribute]
--> torch/onnx/_internal/exporter/_core.py:171:66
|
171 | f"Cannot take content out from the FakeTensor ('{self.name}'). Please replace the tensor "
| ^^^^^^^^^
|
ERROR Argument `str` is not assignable to parameter `object` with type `int` in function `list.append` [bad-argument-type]
--> torch/onnx/_internal/exporter/_core.py:241:29
|
241 | dims.append(str(dim.node))
| ^^^^^^^^^^^^^
|
ERROR Argument `Iterator[tuple[str, Tensor]]` is not assignable to parameter `*iterables` with type `Iterable[tuple[str, Parameter]]` in function `itertools.chain.__new__` [bad-argument-type]
--> torch/onnx/_internal/exporter/_core.py:1215:9
|
1215 | exported_program.named_buffers(),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Unpacked argument `tuple[object, ...]` is not assignable to varargs type `tuple[*_Ts]` [bad-argument-type]
--> torch/onnx/_internal/exporter/_isolated.py:29:20
|
29 | return func(*args, **kwargs)
| ^^^^^^^^^^^^^^^^^
|
ERROR No matching overload found for function `dict.get` [no-matching-overload]
--> torch/onnx/_internal/exporter/_onnx_program.py:160:34
|
160 | dtype = dtype_mapping.get(type(input), None)
| ^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(key: type[float] | type[int], default: None = None, /) -> TypeAlias[float32, type[floating[_32Bit]]] | type[signedinteger[_64Bit]] | None [closest match]
(key: type[float] | type[int], default: TypeAlias[float32, type[floating[_32Bit]]] | type[signedinteger[_64Bit]], /) -> TypeAlias[float32, type[floating[_32Bit]]] | type[signedinteger[_64Bit]]
(key: type[float] | type[int], default: _T, /) -> _T | TypeAlias[float32, type[floating[_32Bit]]] | type[signedinteger[_64Bit]]
ERROR Object of class `NoneType` has no attribute `run_with_ort_values` [missing-attribute]
--> torch/onnx/_internal/exporter/_onnx_program.py:255:19
|
255 | outputs = self._inference_session.run_with_ort_values(
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `FunctionType` has no attribute `function_ir` [missing-attribute]
--> torch/onnx/_internal/exporter/_registration.py:67:25
|
67 | self.onnx_function.function_ir.domain,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `FunctionType` has no attribute `name` [missing-attribute]
--> torch/onnx/_internal/exporter/_registration.py:68:25
|
68 | self.onnx_function.name,
| ^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `FunctionType` has no attribute `opset` [missing-attribute]
--> torch/onnx/_internal/exporter/_registration.py:69:39
|
69 | opset_version=self.onnx_function.opset.version,
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Cannot index into `dict[str, TypeConstraintParam]` [index-error]
--> torch/onnx/_internal/exporter/_schemas.py:544:56
|
544 | type_constraint = type_constraints[return_param_name]
| ^^^^^^^^^^^^^^^^^
|
Argument `str | None` is not assignable to parameter `key` with type `str` in function `dict.__getitem__`
ERROR Argument `str | None` is not assignable to parameter `name` with type `str` in function `Parameter.__init__` [bad-argument-type]
--> torch/onnx/_internal/exporter/_schemas.py:556:30
|
556 | name=return_param_name,
| ^^^^^^^^^^^^^^^^^
|
ERROR Object of class `SymbolicTensor` has no attribute `shape` [missing-attribute]
--> torch/onnx/_internal/exporter/_tensors.py:33:12
|
33 | if self.shape is None:
| ^^^^^^^^^^
|
ERROR Argument `object` is not assignable to parameter `obj` with type `Sized` in function `len` [bad-argument-type]
--> torch/onnx/_internal/exporter/_tensors.py:35:20
|
35 | return len(self.shape)
| ^^^^^^^^^^
|
ERROR Object of class `SymbolicTensor` has no attribute `dtype` [missing-attribute]
--> torch/onnx/_internal/exporter/_tensors.py:40:12
|
40 | if self.dtype in {
| ^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `dtype` [missing-attribute]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:53:69
|
53 | weight = op21.ConstantOfShape(c, value=ir.tensor(1.0, dtype=input.dtype))
| ^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `dtype` [missing-attribute]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:55:67
|
55 | bias = op21.ConstantOfShape(c, value=ir.tensor(0.0, dtype=input.dtype))
| ^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `dtype` [missing-attribute]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:83:59
|
83 | weight = op23.Constant(value=ir.tensor(1.0, dtype=input.dtype))
| ^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `shape` [missing-attribute]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:131:16
|
131 | assert len(query.shape) == 4 and len(key.shape) == 4 and len(value.shape) == 4, (
| ^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `shape` [missing-attribute]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:131:42
|
131 | assert len(query.shape) == 4 and len(key.shape) == 4 and len(value.shape) == 4, (
| ^^^^^^^^^
|
ERROR Object of class `object` has no attribute `shape` [missing-attribute]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:131:66
|
131 | assert len(query.shape) == 4 and len(key.shape) == 4 and len(value.shape) == 4, (
| ^^^^^^^^^^^
|
ERROR Cannot index into `object` [index-error]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:139:17
|
139 | query.shape[1] > key.shape[1] == value.shape[1]
| ^^^^^^^^^^^^^^
|
Object of class `object` has no attribute `__getitem__`
ERROR Cannot index into `object` [index-error]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:139:34
|
139 | query.shape[1] > key.shape[1] == value.shape[1]
| ^^^^^^^^^^^^
|
Object of class `object` has no attribute `__getitem__`
ERROR Cannot index into `object` [index-error]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:139:50
|
139 | query.shape[1] > key.shape[1] == value.shape[1]
| ^^^^^^^^^^^^^^
|
Object of class `object` has no attribute `__getitem__`
ERROR Cannot index into `object` [index-error]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:140:21
|
140 | and query.shape[1] % key.shape[1] == 0
| ^^^^^^^^^^^^^^
|
Object of class `object` has no attribute `__getitem__`
ERROR Cannot index into `object` [index-error]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:140:38
|
140 | and query.shape[1] % key.shape[1] == 0
| ^^^^^^^^^^^^
|
Object of class `object` has no attribute `__getitem__`
ERROR Cannot index into `object` [index-error]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:145:20
|
145 | assert query.shape[1] == key.shape[1] == value.shape[1], (
| ^^^^^^^^^^^^^^
|
Object of class `object` has no attribute `__getitem__`
ERROR Cannot index into `object` [index-error]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:145:38
|
145 | assert query.shape[1] == key.shape[1] == value.shape[1], (
| ^^^^^^^^^^^^
|
Object of class `object` has no attribute `__getitem__`
ERROR Cannot index into `object` [index-error]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:145:54
|
145 | assert query.shape[1] == key.shape[1] == value.shape[1], (
| ^^^^^^^^^^^^^^
|
Object of class `object` has no attribute `__getitem__`
ERROR Object of class `object` has no attribute `shape` [missing-attribute]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:205:9
|
205 | query.shape[1] > key.shape[1] == value.shape[1]
| ^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `shape` [missing-attribute]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:205:26
|
205 | query.shape[1] > key.shape[1] == value.shape[1]
| ^^^^^^^^^
|
ERROR Object of class `object` has no attribute `shape` [missing-attribute]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:205:42
|
205 | query.shape[1] > key.shape[1] == value.shape[1]
| ^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `shape` [missing-attribute]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:206:13
|
206 | and query.shape[1] % key.shape[1] == 0
| ^^^^^^^^^^^
|
ERROR Object of class `object` has no attribute `shape` [missing-attribute]
--> torch/onnx/_internal/exporter/_torchlib/ops/nn.py:206:30
|
206 | and query.shape[1] % key.shape[1] == 0
| ^^^^^^^^^
|
ERROR Cannot index into `dict[dtype, JitScalarType]` [index-error]
--> torch/onnx/_internal/torchscript_exporter/_type_utils.py:156:38
|
156 | return _DTYPE_TO_SCALAR_TYPE[dtype]
| ^^^^^
|
Argument `dtype | None` is not assignable to parameter `key` with type `dtype` in function `dict.__getitem__`
ERROR No matching overload found for function `zip.__new__` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_helper.py:367:51
|
367 | for arg, arg_desc, arg_name in zip(args, arg_descriptors, arg_names)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(cls: type[zip[_T_co]], *, strict: bool = ...) -> zip[Any] [closest match]
(cls: type[zip[_T_co]], iter1: Iterable[_T1], /, *, strict: bool = ...) -> zip[tuple[_T1]]
(cls: type[zip[_T_co]], iter1: Iterable[_T1], iter2: Iterable[_T2], /, *, strict: bool = ...) -> zip[tuple[_T1, _T2]]
(cls: type[zip[_T_co]], iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /, *, strict: bool = ...) -> zip[tuple[_T1, _T2, _T3]]
(cls: type[zip[_T_co]], iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /, *, strict: bool = ...) -> zip[tuple[_T1, _T2, _T3, _T4]]
(cls: type[zip[_T_co]], iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], /, *, strict: bool = ...) -> zip[tuple[_T1, _T2, _T3, _T4, _T5]]
(cls: type[zip[_T_co]], iter1: Iterable[Any], iter2: Iterable[Any], iter3: Iterable[Any], iter4: Iterable[Any], iter5: Iterable[Any], iter6: Iterable[Any], /, *iterables: Iterable[Any], *, strict: bool = ...) -> zip[tuple[Any, ...]]
ERROR Object of class `NoneType` has no attribute `isCompleteTensor`
Object of class `Tensor` has no attribute `isCompleteTensor` [missing-attribute]
--> torch/onnx/_internal/torchscript_exporter/symbolic_helper.py:1803:16
|
1803 | if input.isCompleteTensor():
| ^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Tensor | Value | None` is not assignable to parameter `value` with type `Value` in function `torch.onnx.errors.SymbolicValueError.__init__` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_helper.py:1809:25
|
1809 | input,
| ^^^^^
|
ERROR Object of class `NoneType` has no attribute `isCompleteTensor`
Object of class `Tensor` has no attribute `isCompleteTensor` [missing-attribute]
--> torch/onnx/_internal/torchscript_exporter/symbolic_helper.py:1812:16
|
1812 | if input.isCompleteTensor() and not _is_fp(input):
| ^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Tensor | Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_helper.py:1815:21
|
1815 | input,
| ^^^^^
|
ERROR Argument `Tensor | Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_helper.py:1819:26
|
1819 | self = g.op(op_name, *inputs, **kwargs)
| ^^^^^^^
|
ERROR Returned type `tuple[Sequence[int] | list[int], Sequence[int] | list[int], Sequence[int] | int | list[int], Sequence[int] | list[int]]` is not assignable to declared return type `tuple[Sequence[int], Sequence[int], Sequence[int], Sequence[int]]` [bad-return]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset10.py:208:12
|
208 | return (kernel_shape, strides, pads, dilation)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Returned type `tuple[Sequence[int] | list[int], Sequence[int] | list[int], int | list[int]]` is not assignable to declared return type `tuple[Sequence[int], Sequence[int], Sequence[int]]` [bad-return]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset10.py:384:12
|
384 | return (kernel_shape, strides, pads)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Object of class `NoneType` has no attribute `float` [missing-attribute]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset10.py:712:13
|
712 | scale = scale.float().data # Avoid exporter generating double type
| ^^^^^^^^^^^
|
ERROR `list[Value] | list[Unknown]` is not subscriptable [unsupported-operation]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset11.py:222:54
|
222 | indices_list[idx_] = g.op("NonZero", indices_list[idx_])
| ^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset11.py:822:45
|
822 | return g.op("Range", start_default, end, delta_default)
| ^^^
|
ERROR Argument `Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset11.py:833:30
|
833 | return g.op("Range", start, end, step)
| ^^^^^
|
ERROR Argument `Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset11.py:833:37
|
833 | return g.op("Range", start, end, step)
| ^^^
|
ERROR Argument `Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset11.py:833:42
|
833 | return g.op("Range", start, end, step)
| ^^^^
|
ERROR Argument `Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset11.py:844:30
|
844 | return g.op("Range", start, end, delta_default)
| ^^^^^
|
ERROR Argument `Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset11.py:844:37
|
844 | return g.op("Range", start, end, delta_default)
| ^^^
|
ERROR Argument `Literal[TensorProtoDataType.BOOL]` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset12.py:366:37
|
366 | "Cast", loop_condition, _C_onnx.TensorProtoDataType.BOOL
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `outputs` with type `int` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset13.py:99:77
|
99 | return g.op("Split", self, split_size_or_sizes, axis_i=dim, outputs=_outputs)
| ^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `outputs` with type `int` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset13.py:115:60
|
115 | return g.op("Split", self, splits, axis_i=dim, outputs=_outputs)
| ^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `outputs` with type `int` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset13.py:189:64
|
189 | return g.op("Split", self, splits, axis_i=dim, outputs=_outputs)
| ^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset13.py:314:43
|
314 | return g.op("Where", condition, self, other)
| ^^^^^
|
ERROR No matching overload found for function `range.__new__` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset14.py:170:37
|
170 | key_transposed_axes = list(range(key_shape_builtin))
| ^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(cls: type[range], stop: SupportsIndex, /) -> range [closest match]
(cls: type[range], start: SupportsIndex, stop: SupportsIndex, step: SupportsIndex = ..., /) -> range
ERROR Argument `Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset14.py:179:52
|
179 | query_scaled = g.op("Mul", query, g.op("Sqrt", scale))
| ^^^^^
|
ERROR Argument `Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset14.py:180:70
|
180 | key_transposed_scaled = g.op("Mul", key_transposed, g.op("Sqrt", scale))
| ^^^^^
|
ERROR Argument `Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset14.py:193:35
|
193 | attn_mask = g.op("Where", attn_mask, const_zero, const_neg_inf)
| ^^^^^^^^^
|
ERROR Argument `Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset14.py:206:42
|
206 | mul_qk_add = g.op("Add", mul_qk, attn_mask)
| ^^^^^^^^^
|
ERROR Argument `Value | None` is not assignable to parameter `x` with type `Value` in function `torch.onnx._internal.torchscript_exporter.symbolic_helper._get_tensor_dim_size` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset17.py:179:50
|
179 | n_win = symbolic_helper._get_tensor_dim_size(window, dim=0)
| ^^^^^^
|
ERROR Argument `Value | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset17.py:192:47
|
192 | window = g.op("Concat", left_win, window, right_win, axis_i=0)
| ^^^^^^
|
ERROR Argument `Value | Unknown | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset17.py:215:17
|
215 | "Cast", window, to_i=_type_utils.JitScalarType.from_value(signal).onnx_type()
| ^^^^^^
|
ERROR No matching overload found for function `max` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset18.py:154:15
|
154 | return max(g, input, dim_or_y=other)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(arg1: SupportsRichComparisonT, arg2: SupportsRichComparisonT, /, *_args: SupportsRichComparisonT, *, key: None = None) -> SupportsRichComparisonT [closest match]
(arg1: _T, arg2: _T, /, *_args: _T, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None) -> SupportsRichComparisonT
(iterable: Iterable[_T], /, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, default: _T) -> SupportsRichComparisonT | _T
(iterable: Iterable[_T1], /, *, key: (_T1) -> SupportsDunderGT[Any] | SupportsDunderLT[Any], default: _T2) -> _T1 | _T2
ERROR No matching overload found for function `min` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset18.py:166:15
|
166 | return min(g, input, dim_or_y=other)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(arg1: SupportsRichComparisonT, arg2: SupportsRichComparisonT, /, *_args: SupportsRichComparisonT, *, key: None = None) -> SupportsRichComparisonT [closest match]
(arg1: _T, arg2: _T, /, *_args: _T, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None) -> SupportsRichComparisonT
(iterable: Iterable[_T], /, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, default: _T) -> SupportsRichComparisonT | _T
(iterable: Iterable[_T1], /, *, key: (_T1) -> SupportsDunderGT[Any] | SupportsDunderLT[Any], default: _T2) -> _T1 | _T2
ERROR Argument `Unknown | None` is not assignable to parameter `outputs` with type `int` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:1054:68
|
1054 | return g.op("Split", self, split_i=splits, axis_i=dim, outputs=_outputs)
| ^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `outputs` with type `int` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:1071:73
|
1071 | return g.op("Split", self, split_i=split_sizes, axis_i=dim, outputs=_outputs)
| ^^^^^^^^
|
ERROR Expected a callable, got `None` [not-callable]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:1708:20
|
1708 | return fn(g, input, k, k, (0,) * len(dim), (1,) * len(dim), False)
| ^^
|
ERROR Argument `int | None` is not assignable to parameter `dim` with type `int` in function `_prepare_onnx_paddings` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:1762:39
|
1762 | paddings = _prepare_onnx_paddings(symbolic_helper._get_tensor_rank(input), padding)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `int | None` is not assignable to parameter `dim` with type `int` in function `_prepare_onnx_paddings` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:1815:39
|
1815 | paddings = _prepare_onnx_paddings(symbolic_helper._get_tensor_rank(input), padding)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `int | None` is not assignable to parameter `dim` with type `int` in function `_prepare_onnx_paddings` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:1827:39
|
1827 | paddings = _prepare_onnx_paddings(symbolic_helper._get_tensor_rank(input), padding)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:2207:43
|
2207 | return g.op("Where", condition, self, other)
| ^^^^^
|
ERROR Unpacked keyword argument `str | Unknown` is not assignable to parameter `outputs` with type `int` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:2382:29
|
2382 | n = g.op("Conv", *args, **kwargs)
| ^^^^^^^^
|
ERROR No matching overload found for function `pow` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:2726:42
|
2726 | variance = g.op("ReduceMean", pow(g, numerator, two_cst), axes_i=axes)
| ^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(base: int, exp: int, mod: int) -> int [closest match]
(base: int, exp: Literal[0], mod: None = None) -> Literal[1]
(base: int, exp: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], mod: None = None) -> int
(base: int, exp: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], mod: None = None) -> float
(base: int, exp: int, mod: None = None) -> Any
(base: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], exp: float, mod: None = None) -> float
(base: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], exp: float, mod: None = None) -> complex
(base: float, exp: int, mod: None = None) -> float
(base: float, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> Any
(base: complex, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> complex
(base: _SupportsPow2[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3NoneOnly[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3[_E_contra, _M_contra, _T_co], exp: _E_contra, mod: _M_contra) -> _T_co
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: float, mod: None = None) -> Any
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: complex, mod: None = None) -> complex
ERROR No matching overload found for function `pow` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:2730:16
|
2730 | pow(g, numerator, two_cst),
| ^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(base: int, exp: int, mod: int) -> int [closest match]
(base: int, exp: Literal[0], mod: None = None) -> Literal[1]
(base: int, exp: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], mod: None = None) -> int
(base: int, exp: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], mod: None = None) -> float
(base: int, exp: int, mod: None = None) -> Any
(base: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], exp: float, mod: None = None) -> float
(base: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], exp: float, mod: None = None) -> complex
(base: float, exp: int, mod: None = None) -> float
(base: float, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> Any
(base: complex, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> complex
(base: _SupportsPow2[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3NoneOnly[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3[_E_contra, _M_contra, _T_co], exp: _E_contra, mod: _M_contra) -> _T_co
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: float, mod: None = None) -> Any
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: complex, mod: None = None) -> complex
ERROR No matching overload found for function `pow` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:3068:12
|
3068 | pow(g, sub(g, input1, input2), p),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(base: int, exp: int, mod: int) -> int [closest match]
(base: int, exp: Literal[0], mod: None = None) -> Literal[1]
(base: int, exp: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], mod: None = None) -> int
(base: int, exp: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], mod: None = None) -> float
(base: int, exp: int, mod: None = None) -> Any
(base: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], exp: float, mod: None = None) -> float
(base: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], exp: float, mod: None = None) -> complex
(base: float, exp: int, mod: None = None) -> float
(base: float, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> Any
(base: complex, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> complex
(base: _SupportsPow2[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3NoneOnly[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3[_E_contra, _M_contra, _T_co], exp: _E_contra, mod: _M_contra) -> _T_co
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: float, mod: None = None) -> Any
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: complex, mod: None = None) -> complex
ERROR No matching overload found for function `pow` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:3072:15
|
3072 | return pow(g, summation, inv_p)
| ^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(base: int, exp: int, mod: int) -> int [closest match]
(base: int, exp: Literal[0], mod: None = None) -> Literal[1]
(base: int, exp: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], mod: None = None) -> int
(base: int, exp: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], mod: None = None) -> float
(base: int, exp: int, mod: None = None) -> Any
(base: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], exp: float, mod: None = None) -> float
(base: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], exp: float, mod: None = None) -> complex
(base: float, exp: int, mod: None = None) -> float
(base: float, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> Any
(base: complex, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> complex
(base: _SupportsPow2[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3NoneOnly[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3[_E_contra, _M_contra, _T_co], exp: _E_contra, mod: _M_contra) -> _T_co
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: float, mod: None = None) -> Any
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: complex, mod: None = None) -> complex
ERROR No matching overload found for function `max` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:3181:15
|
3181 | return max(g, input, dim_or_y=other)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(arg1: SupportsRichComparisonT, arg2: SupportsRichComparisonT, /, *_args: SupportsRichComparisonT, *, key: None = None) -> SupportsRichComparisonT [closest match]
(arg1: _T, arg2: _T, /, *_args: _T, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None) -> SupportsRichComparisonT
(iterable: Iterable[_T], /, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, default: _T) -> SupportsRichComparisonT | _T
(iterable: Iterable[_T1], /, *, key: (_T1) -> SupportsDunderGT[Any] | SupportsDunderLT[Any], default: _T2) -> _T1 | _T2
ERROR No matching overload found for function `min` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:3193:15
|
3193 | return min(g, input, dim_or_y=other)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(arg1: SupportsRichComparisonT, arg2: SupportsRichComparisonT, /, *_args: SupportsRichComparisonT, *, key: None = None) -> SupportsRichComparisonT [closest match]
(arg1: _T, arg2: _T, /, *_args: _T, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None) -> SupportsRichComparisonT
(iterable: Iterable[_T], /, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, default: _T) -> SupportsRichComparisonT | _T
(iterable: Iterable[_T1], /, *, key: (_T1) -> SupportsDunderGT[Any] | SupportsDunderLT[Any], default: _T2) -> _T1 | _T2
ERROR Argument `Unknown | None` is not assignable to parameter `value` with type `int` in function `enum.IntEnum.__new__` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:3489:49
|
3489 | scalar_type = _type_utils.JitScalarType(dtype)
| ^^^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `value` with type `int` in function `enum.IntEnum.__new__` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:3548:49
|
3548 | scalar_type = _type_utils.JitScalarType(dtype)
| ^^^^^
|
ERROR No matching overload found for function `max` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:5537:35
|
5537 | result, _indices = max(
| ___________________________________^
5538 | | g,
5539 | | sum,
5540 | | dim_or_y=g.op("Constant", value_t=torch.LongTensor([dim[1]])),
5541 | | keepdim=keepdim,
5542 | | )
| |_____________^
|
Possible overloads:
(arg1: SupportsRichComparisonT, arg2: SupportsRichComparisonT, /, *_args: SupportsRichComparisonT, *, key: None = None) -> SupportsRichComparisonT [closest match]
(arg1: _T, arg2: _T, /, *_args: _T, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None) -> SupportsRichComparisonT
(iterable: Iterable[_T], /, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, default: _T) -> SupportsRichComparisonT | _T
(iterable: Iterable[_T1], /, *, key: (_T1) -> SupportsDunderGT[Any] | SupportsDunderLT[Any], default: _T2) -> _T1 | _T2
ERROR No matching overload found for function `min` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:5544:35
|
5544 | result, _indices = min(
| ___________________________________^
5545 | | g,
5546 | | sum,
5547 | | dim_or_y=g.op("Constant", value_t=torch.LongTensor([dim[1]])),
5548 | | keepdim=keepdim,
5549 | | )
| |_____________^
|
Possible overloads:
(arg1: SupportsRichComparisonT, arg2: SupportsRichComparisonT, /, *_args: SupportsRichComparisonT, *, key: None = None) -> SupportsRichComparisonT [closest match]
(arg1: _T, arg2: _T, /, *_args: _T, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None) -> SupportsRichComparisonT
(iterable: Iterable[_T], /, *, key: (_T) -> SupportsDunderGT[Any] | SupportsDunderLT[Any]) -> _T
(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, default: _T) -> SupportsRichComparisonT | _T
(iterable: Iterable[_T1], /, *, key: (_T1) -> SupportsDunderGT[Any] | SupportsDunderLT[Any], default: _T2) -> _T1 | _T2
ERROR Argument `Unknown | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:5907:31
|
5907 | ind = g.op("Add", ind, g.op("Constant", torch.tensor([offset])))
| ^^^
|
ERROR Argument `Unknown | None` is not assignable to parameter `*raw_args` with type `Tensor | Value` in function `torch.onnx._internal.torchscript_exporter.jit_utils.GraphContext.op` [bad-argument-type]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:5908:40
|
5908 | return g.op("Gather", self_1d, ind)
| ^^^
|
ERROR No matching overload found for function `pow` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:6190:12
|
6190 | pow(g, x1, symbolic_helper._generate_wrapped_number(g, 2.0)),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(base: int, exp: int, mod: int) -> int [closest match]
(base: int, exp: Literal[0], mod: None = None) -> Literal[1]
(base: int, exp: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], mod: None = None) -> int
(base: int, exp: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], mod: None = None) -> float
(base: int, exp: int, mod: None = None) -> Any
(base: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], exp: float, mod: None = None) -> float
(base: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], exp: float, mod: None = None) -> complex
(base: float, exp: int, mod: None = None) -> float
(base: float, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> Any
(base: complex, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> complex
(base: _SupportsPow2[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3NoneOnly[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3[_E_contra, _M_contra, _T_co], exp: _E_contra, mod: _M_contra) -> _T_co
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: float, mod: None = None) -> Any
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: complex, mod: None = None) -> complex
ERROR No matching overload found for function `pow` [no-matching-overload]
--> torch/onnx/_internal/torchscript_exporter/symbolic_opset9.py:6197:12
|
6197 | pow(g, x2, symbolic_helper._generate_wrapped_number(g, 2.0)),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
Possible overloads:
(base: int, exp: int, mod: int) -> int [closest match]
(base: int, exp: Literal[0], mod: None = None) -> Literal[1]
(base: int, exp: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], mod: None = None) -> int
(base: int, exp: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], mod: None = None) -> float
(base: int, exp: int, mod: None = None) -> Any
(base: Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25], exp: float, mod: None = None) -> float
(base: Literal[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1], exp: float, mod: None = None) -> complex
(base: float, exp: int, mod: None = None) -> float
(base: float, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> Any
(base: complex, exp: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any] | complex, mod: None = None) -> complex
(base: _SupportsPow2[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3NoneOnly[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co
(base: _SupportsPow3[_E_contra, _M_contra, _T_co], exp: _E_contra, mod: _M_contra) -> _T_co
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: float, mod: None = None) -> Any
(base: _SupportsPow2[Any, Any] | _SupportsPow3[Any, Any, Any] | _SupportsPow3NoneOnly[Any, Any], exp: complex, mod: None = None) -> complex
ERROR Object of class `Buffer` has no attribute `shape`
Object of class `_NestedSequence` has no attribute `shape`
Object of class `_SupportsArray` has no attribute `shape`
Object of class `bool` has no attribute `shape`
Object of class `bytes` has no attribute `shape`
Object of class `complex` has no attribute `shape`
Object of class `float` has no attribute `shape`
Object of class `int` has no attribute `shape`
Object of class `str` has no attribute `shape` [missing-attribute]
--> torch/onnx/_internal/torchscript_exporter/verification.py:242:29
|
242 | ) / np.prod(ort_out.shape)
| ^^^^^^^^^^^^^
|
ERROR Object of class `Buffer` has no attribute `dtype`
Object of class `_NestedSequence` has no attribute `dtype`
Object of class `_SupportsArray` has no attribute `dtype`
Object of class `bool` has no attribute `dtype`
Object of class `bytes` has no attribute `dtype`
Object of class `complex` has no attribute `dtype`
Object of class `float` has no attribute `dtype`
Object of class `int` has no attribute `dtype`
Object of class `str` has no attribute `dtype` [missing-attribute]
--> torch/onnx/_internal/torchscript_exporter/verification.py:250:16
|
250 | if ort_out.dtype == np.uint8 or ort_out.dtype == np.int8:
| ^^^^^^^^^^^^^
|
ERROR Object of class `Buffer` has no attribute `dtype`
Object of class `_NestedSequence` has no attribute `dtype`
Object of class `_SupportsArray` has no attribute `dtype`
Object of class `bool` has no attribute `dtype`
Object of class `bytes` has no attribute `dtype`
Object of class `complex` has no attribute `dtype`
Object of class `float` has no attribute `dtype`
Object of class `int` has no attribute `dtype`
Object of class `str` has no attribute `dtype` [missing-attribute]
--> torch/onnx/_internal/torchscript_exporter/verification.py:252:16
|
252 | if pt_out.dtype == np.uint8 or pt_out.dtype == np.int8:
| ^^^^^^^^^^^^
|
WARN `select_model_mode_for_export` is deprecated [deprecated]
--> torch/onnx/utils.py:8:61
|
8 | from torch.onnx._internal.torchscript_exporter.utils import * # noqa: F401,F403
| -
|
WARN `disable_apex_o2_state_dict_hook` is deprecated [deprecated]
--> torch/onnx/utils.py:8:61
|
8 | from torch.onnx._internal.torchscript_exporter.utils import * # noqa: F401,F403
| -
|
WARN `setup_onnx_logging` is deprecated [deprecated]
--> torch/onnx/utils.py:8:61
|
8 | from torch.onnx._internal.torchscript_exporter.utils import * # noqa: F401,F403
| -
|
WARN `exporter_context` is deprecated [deprecated]
--> torch/onnx/utils.py:8:61
|
8 | from torch.onnx._internal.torchscript_exporter.utils import * # noqa: F401,F403
| -
|
WARN `unconvertible_ops` is deprecated [deprecated]
--> torch/onnx/utils.py:8:61
|
8 | from torch.onnx._internal.torchscript_exporter.utils import * # noqa: F401,F403
| -
|
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment