Descarga de torchtyping - Descargar el código fuente torchtyping

torchtyping

Pitón

1.0.0

Descargar

antorchas

Tipo de anotaciones para una forma de tensor, dtype, nombres, ...

¡Bienvenido! Para nuevos proyectos, ahora recomiendo usar mi nuevo proyecto de jaxtyping. Es compatible con Pytorch, en realidad no depende de Jax, y a diferencia de la antorchtyping es compatible con los damas de tipo estático. :)

Vuelve esto:

 def batch_outer_product ( x : torch . Tensor , y : torch . Tensor ) -> torch . Tensor :
    # x has shape (batch, x_channels)
    # y has shape (batch, y_channels)
    # return has shape (batch, x_channels, y_channels)

    return x . unsqueeze ( - 1 ) * y . unsqueeze ( - 2 )

En esto:

 def batch_outer_product ( x :   TensorType [ "batch" , "x_channels" ],
                        y :   TensorType [ "batch" , "y_channels" ]
                        ) -> TensorType [ "batch" , "x_channels" , "y_channels" ]:

    return x . unsqueeze ( - 1 ) * y . unsqueeze ( - 2 )

con verificación programática que se cumple la especificación de forma (dtype, ...).

¡Bugs adiós! Saluda a la documentación exitosa y clara de su código.

Si (como yo) se encuentra con su código con comentarios como # x has shape (batch, hidden_state) o declaraciones como assert x.shape == y.shape , solo para realizar un seguimiento de qué forma es todo, entonces esto es para usted.

Instalación

pip install torchtyping

Requiere Python> = 3.7 y Pytorch> = 1.7.0.

Si usa typeguard , entonces debe ser una versión <3.0.0.

Uso

torchtyping permite anotar el tipo:

Forma : tamaño, número de dimensiones;
dtype (flotante, entero, etc.);
diseño (denso, escaso);
nombres de dimensiones según los tensores nombrados;
Número arbitrario de dimensiones por lotes con ... ;
... además de cualquier otra cosa que quieras , ya que torchtyping es muy extensible.

Si typeguard está (opcionalmente) instalado, entonces en tiempo de ejecución se puede verificar los tipos para asegurarse de que los tensores realmente sean de forma anunciada, dtype, etc.

 # EXAMPLE

from torch import rand
from torchtyping import TensorType , patch_typeguard
from typeguard import typechecked

patch_typeguard ()  # use before @typechecked

@ typechecked
def func ( x : TensorType [ "batch" ],
         y : TensorType [ "batch" ]) -> TensorType [ "batch" ]:
    return x + y

func ( rand ( 3 ), rand ( 3 ))  # works
func ( rand ( 3 ), rand ( 1 ))
# TypeError: Dimension 'batch' of inconsistent size. Got both 1 and 3.

typeguard también tiene un gancho de importación que se puede usar para probar automáticamente un módulo completo, sin necesidad de agregar manualmente los decoradores @typeguard.typechecked .

Si no está usando typeguard entonces torchtyping.patch_typeguard() se puede omitir por completo, y torchtyping se usa para fines de documentación. Si aún no está usando typeguard para su programación regular de Python, entonces considere encarecidamente usarla. Es una excelente manera de aplastar los insectos. Tanto typeguard como torchtyping también se integran con pytest , por lo que si le preocupa cualquier penalización de rendimiento, solo pueden habilitarse durante las pruebas.

API

 torchtyping . TensorType [ shape , dtype , layout , details ]

El núcleo de la biblioteca.

Cada uno de shape , dtype , layout y details son opcionales.

El argumento shape puede ser cualquiera de:
- Un int : la dimensión debe ser exactamente de este tamaño. Si es -1 entonces se permite cualquier tamaño.
- Un str : el tamaño de la dimensión pasada en tiempo de ejecución estará vinculado a este nombre, y todos los tensores verificarán que los tamaños son consistentes.
- A ... : un número arbitrario de dimensiones de cualquier tamaño.
- A str: int Par (técnicamente es una porción), que combina el comportamiento str e int . (Solo un str por sí solo es equivalente a str: -1 .)
- Un par str: str , en cuyo caso el tamaño de la dimensión pasada en tiempo de ejecución estará vinculado a ambos nombres, y todas las dimensiones con cualquier nombre deben tener el mismo tamaño. (A algunas personas les gusta usar esto como una forma de asociar múltiples nombres con una dimensión, para fines de documentación adicionales).
- Un str: ... par, en cuyo caso las múltiples dimensiones correspondientes a ... estarán unidas al nombre especificado por str , y nuevamente verificarán la consistencia entre los argumentos.
- None , que cuando se usa junto con is_named a continuación, indica una dimensión que no debe tener un nombre en el sentido de tensores nombrados.
- A None: int Par, combinando None e int Comportamiento. (Solo un None por sí solo es equivalente a None: -1 .)
- A None: str , combinando el comportamiento de None y str . (Es decir, no debe tener una dimensión con nombre, pero debe ser de un tamaño consistente con otros usos de la cadena).
- Una typing.Any . En cualquier tamaño: se permite cualquier tamaño para esta dimensión (equivalente a -1 ).
- Cualquier tupla de lo anterior. Por ejemplo. TensorType["batch": ..., "length": 10, "channels", -1] . Si solo desea especificar el número de dimensiones, use, por ejemplo, TensorType[-1, -1, -1] para un tensor tridimensional.
El argumento dtype puede ser cualquiera de:
- torch.float32 , torch.float64 etc.
- int , bool , float , que se convierten en sus tipos de pytorch correspondientes. float se interpreta específicamente como torch.get_default_dtype() , que generalmente es float32 .
El argumento layout puede ser torch.strided o torch.sparse_coo , para tensores densos y escasos, respectivamente.
El argumento details ofrece una forma de pasar un número arbitrario de banderas adicionales que personalizan y extienden torchtyping . Dos banderas están incorporadas de forma predeterminada. torchtyping.is_named hace que se verifiquen los nombres torchtyping las dimensiones del TensorType[torch.float32] , details torchtyping.is_float .
Verifique varias cosas a la vez simplemente poniéndolas todas dentro de un solo [] . Por ejemplo TensorType["batch": ..., "length", "channels", float, is_named] .

 torchtyping . patch_typeguard ()

torchtyping se integra con typeguard para realizar una verificación de tipo de ejecución. torchtyping.patch_typeguard() debe llamarse a nivel global, y parchará typeguard para verificar TensorType s.

Esta función es segura para ejecutar varias veces. (No hace nada después de la primera carrera).

Si usa @typeguard.typechecked , entonces torchtyping.patch_typeguard() debe llamarse en cualquier momento antes de usar @typeguard.typechecked . Por ejemplo, puede llamarlo al comienzo de cada archivo usando torchtyping .
Si usa typeguard.importhook.install_import_hook , entonces torchtyping.patch_typeguard() debe llamarse en cualquier momento antes de definir las funciones que desea verificar. Por ejemplo, puede llamar a torchtyping.patch_typeguard() solo una vez, al mismo tiempo que el gancho de importación typeguard . (El orden del gancho y el parche no importa).
Si no está usando typeguard , entonces torchtyping.patch_typeguard() se puede omitir por completo, y torchtyping se usa para fines de documentación.

pytest --torchtyping-patch-typeguard

torchtyping ofrece un complemento pytest para ejecutar automáticamente torchtyping.patch_typeguard() antes de sus pruebas. pytest descubrirá automáticamente el complemento, solo necesita pasar la bandera --torchtyping-patch-typeguard para habilitarlo. Los paquetes se pueden pasar a typeguard como normal, ya sea usando @typeguard.typechecked , el gancho de importación de typeguard o la bandera pytest --typeguard-packages="your_package_here" .