# torch.overrides

> 原文：[`pytorch.org/docs/stable/torch.overrides.html`](https://pytorch.org/docs/stable/torch.overrides.html)

此模块公开了各种辅助函数，用于`__torch_function__`协议。有关`__torch_function__`协议的更多详细信息，请参见扩展 torch Python API。

## 函数

```py
torch.overrides.get_ignored_functions()
```

返回不能通过`__torch_function__`覆盖的公共函数。

返回

一个元组，其中包含在 torch API 中公开但不能使用`__torch_function__`覆盖的函数。主要是因为这些函数的参数都不是张量或类似张量。

返回类型

Set[Callable]

示例

```py
>>> torch.Tensor.as_subclass in torch.overrides.get_ignored_functions()
True
>>> torch.add in torch.overrides.get_ignored_functions()
False 
```

```py
torch.overrides.get_overridable_functions()
```

列出可以通过 __torch_function__ 覆盖的函数

返回

一个将包含可重写函数的命名空间映射到该命名空间中可重写的函数的字典。

返回类型

Dict[Any, List[Callable]]

```py
torch.overrides.resolve_name(f)
```

获取传递给 __torch_function__ 的函数的人类可读字符串名称

参数

**f** (*Callable*) - 要解析名称的函数。

返回

函数的名称；如果对其进行 eval，则应返回输入函数。

返回类型

[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")

```py
torch.overrides.get_testing_overrides()
```

返回一个包含所有可重写函数的虚拟覆盖的字典

返回

一个字典，将 PyTorch API 中可重写函数映射到具有与真实函数相同签名的 lambda 函数，这些 lambda 函数无条件返回-1。这些 lambda 函数对于测试为定义`__torch_function__`的类型的 API 覆盖率很有用。

返回类型

Dict[Callable, Callable]

示例

```py
>>> import inspect
>>> my_add = torch.overrides.get_testing_overrides()[torch.add]
>>> inspect.signature(my_add)
<Signature (input, other, out=None)> 
```

```py
torch.overrides.handle_torch_function(public_api, relevant_args, *args, **kwargs)
```

实现带有`__torch_function__`覆盖的函数。

请参阅 torch::autograd::handle_torch_function，了解 C++实现中此函数的等效部分。

参数

+   **public_api** (*function*) - 最初在公共 torch API 中调用的函数，如`public_api(*args, **kwargs)`，现在正在检查其参数。

+   **relevant_args** (*iterable*) - 要检查 __torch_function__ 方法的参数的可迭代对象。

+   **args** ([*tuple*](https://docs.python.org/3/library/stdtypes.html#tuple "(在 Python v3.12 中)")) - 最初传递给`public_api`的任意位置参数。

+   **kwargs** ([*tuple*](https://docs.python.org/3/library/stdtypes.html#tuple "(在 Python v3.12 中)")) - 最初传递给`public_api`的任意关键字参数。

返回

调用`implementation`或适当的`__torch_function__`方法的结果。

返回类型

[object](https://docs.python.org/3/library/functions.html#object "(在 Python v3.12 中)")

:如果找不到实现，则引发 TypeError。:

示例

```py
>>> def func(a):
...     if has_torch_function_unary(a):
...         return handle_torch_function(func, (a,), a)
...     return a + 0 
```

```py
torch.overrides.has_torch_function()
```

检查可迭代对象中元素的 __torch_function__ 实现，或者是否启用了 __torch_function__ 模式。将确切的`Tensor`和`Parameter`视为不可分派。使用此功能来保护对`handle_torch_function()`的调用；不要用它来测试某物是否类似于 Tensor，而是使用`is_tensor_like()`。:param relevant_args: 要检查 __torch_function__ 方法的可迭代对象或参数。:type relevant_args: iterable

返回

如果 relevant_args 的任何元素具有 __torch_function__ 实现，则返回 True，否则返回 False。

返回类型

[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")

另请参见

`torch.is_tensor_like`

检查某物是否类似于 Tensor，包括确切的`Tensor`。

```py
torch.overrides.is_tensor_like(inp)
```

如果传入的输入是类似于 Tensor 的，则返回`True`。

当前，只要输入类型的`__torch_function__`属性存在，就会发生这种情况。

示例

张量的子类通常是类似于 Tensor 的。

```py
>>> class SubTensor(torch.Tensor): ...
>>> is_tensor_like(SubTensor([0]))
True 
```

内置或用户类型通常不类似于 Tensor。

```py
>>> is_tensor_like(6)
False
>>> is_tensor_like(None)
False
>>> class NotATensor: ...
>>> is_tensor_like(NotATensor())
False 
```

但是，通过实现 __torch_function__，它们可以变得类似于 Tensor。

```py
>>> class TensorLike:
...     @classmethod
...     def __torch_function__(cls, func, types, args, kwargs):
...         return -1
>>> is_tensor_like(TensorLike())
True 
```

```py
torch.overrides.is_tensor_method_or_property(func)
```

如果传入的函数是`torch.Tensor`的方法或属性的处理程序，则返回 True，如传入`__torch_function__`。

注意

对于属性，必须传递它们的`__get__`方法。

这可能是必要的，特别是出于以下原因：

1.  方法/属性有时不包含 __module__ 槽。

1.  它们要求第一个传入的参数是`torch.Tensor`的实例。

示例

```py
>>> is_tensor_method_or_property(torch.Tensor.add)
True
>>> is_tensor_method_or_property(torch.add)
False 
```

返回类型

[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")

```py
torch.overrides.wrap_torch_function(dispatcher)
```

使用与`__torch_function__`相关的功能包装给定的函数。

参数

**dispatcher**（*Callable*）- 一个可调用对象，返回传递给函数的类似张量的可迭代对象。

注意

这个装饰器可能会降低代码的性能。通常，将代码表达为一系列支持 __torch_function__ 的函数就足够了。如果您发现自己处于罕见的情况，即如果您正在包装一个低级库，并且还需要它适用于类似张量，那么这个函数是可用的。

示例

```py
>>> def dispatcher(a): # Must have the same signature as func
...     return (a,)
>>> @torch.overrides.wrap_torch_function(dispatcher)
>>> def func(a): # This will make func dispatchable by __torch_function__
...     return a + 0 
```